docs: public synchronized FieldList makeRowCurrent(int iRowIndex, boolean bLockRecord)
      {
          FieldList fieldList = null;
          if (m_table == null)
              return null;
          if (iRowIndex == -1)
          {
              this.setCurrentRow(iRowIndex);     // Invalidate the current row
              if (bLockRecord)
                  m_iCurrentLockedRowIndex = iRowIndex;
              return null;
          }
          try   {
              if ((iRowIndex == this.getCurrentRow()) && (!bLockRecord))
                  fieldList = m_table.getRecord();   // Already current record
              else
              {
                  if ((m_iLastRecord == RECORD_UNKNOWN) || (iRowIndex <= m_iLastRecord))
                  {
                      fieldList = (FieldList)m_table.get(iRowIndex);  // Read this record
                      if ((fieldList == null) || (fieldList.getEditMode() == Constants.EDIT_ADD) || (fieldList.getEditMode() == Constants.EDIT_NONE))
                          if (m_iCurrentLockedRowIndex == iRowIndex)
                      {
                          m_iCurrentLockedRowIndex = -1;
                          m_buffCurrentLockedData = null; // This record was deleted, clear the buffer!                 
                      }
                      if (bLockRecord)
                          if (fieldList != null)
                              if (fieldList.getEditMode() == Constants.EDIT_CURRENT)
                              {
                                  if (m_table.edit() == Constants.NORMAL_RETURN)
                                      fieldList = m_table.getRecord();    // A physical read may have changed the record.
                              }
                  }
                  else
                  {   // Past the EOF, just supply a blank record
                      m_table.addNew();
                      fieldList = m_table.getRecord();
                  }
                  int iOldRowCount = this.getRowCount(true);
                  if (fieldList != null) if (m_iLastRecord == RECORD_UNKNOWN)
                  {
                      this.checkRowValue(iRowIndex);
                      if (this.getRowCount(true) > iOldRowCount)
                          this.fireTableRowsInserted(iOldRowCount, this.getRowCount(true) - 1);
                      else if (this.getRowCount(true) < iOldRowCount)
                          this.fireTableRowsDeleted(iOldRowCount, this.getRowCount(true) - 1);
                  }
                  if (fieldList == null)
                  { // Got to end of file!
                      if ((m_iLastRecord == RECORD_UNKNOWN) && (iRowIndex > m_iLargestValidRecord))
                      {
                          if (iRowIndex == m_iLargestValidRecord + 1)
                          {
                              m_iLastRecord = iRowIndex - 1;  // Now I know the actual EOF
                          }
                          else if (iRowIndex > m_iLargestValidRecord + 1)
                          {
                              int iEOF = m_table.size();
                              if (iEOF != -1)
                              {
                                  m_iLastRecord = iEOF - 1;
                                  iRowIndex = m_iLastRecord + 1;
                              }
                              else
                              {   // Okay, the EOF is somewhere between m_iLargestValidRecord+1 and iRowIndex.. find it!
                                  int iTargetIndex = (m_iLargestValidRecord + 1 + iRowIndex) / 2;
                                  while (iTargetIndex > m_iLargestValidRecord + 1)
                                  {
                                      fieldList = (FieldList)m_table.get(iTargetIndex);  // Read this record
                                      if (fieldList != null)
                                          m_iLargestValidRecord = iTargetIndex;
                                      else
                                          iRowIndex = iTargetIndex;
                                      iTargetIndex = (m_iLargestValidRecord + 1 + iRowIndex) / 2;
                                  }
                                  m_iLastRecord = m_iLargestValidRecord;
                                  iRowIndex = m_iLastRecord + 1;
                              }
                          }
                          this.setRowCount(iRowIndex);        // new EOF
                          if (iOldRowCount > this.getRowCount(true))
                              this.fireTableRowsDeleted(this.getRowCount(true), iOldRowCount - 1);
                          if (this.getSelectedRow() != -1)
                          {
                              if (this.getSelectedRow() > this.getRowCount())
                              {
                                  this.makeRowCurrent(this.getRowCount() - 1, false);
  //                                this.selectionChanged(this, this.getRowCount() - 1, this.getRowCount() -1 , DBConstants.SELECT_TYPE);
                              }
                          }
                      }
                      m_table.addNew();
                      fieldList = m_table.getRecord();
                  }
              }
              if ((m_iCurrentLockedRowIndex != -1) && (m_iCurrentLockedRowIndex == iRowIndex)
                  && (m_buffCurrentLockedData != null))
                      this.restoreCurrentRecord(fieldList); // Restore current edit record
          } catch (Exception ex)  {
              if (!this.displayError(ex, null))
                  ex.printStackTrace();
          }
          this.setCurrentRow(iRowIndex);     // Successfully read
          return fieldList;
      }