Reposition to this record Using this bookmark.
@exception DBException File exception.
195235
public FieldList setHandle(Object bookmark, int iHandleType) throws DBException
    {
        FieldList record = super.setHandle(bookmark, iHandleType);
        Iterator<BaseTable> iterator = this.getTables();
        while (iterator.hasNext())
        {
            BaseTable table = iterator.next();
            if ((table != null) && (table != this.getNextTable()))
                this.syncTables(table, this.getRecord());
        }
        return record;
    }
642588
public void doAdd(Rec record) throws DBException
    {
        try   {
            m_objLastModBookmark = m_tableRemote.add(this.getDataSource(), record.getOpenMode());
        } catch (RemoteException ex) {
            throw new DBException(ex.getMessage());
        }
    }
474846
public synchronized void moveToBottom()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "moveToBottom");

    checkEntryParent();
    
    //record the parent list
    LinkedList list = parentList;
    synchronized(list)
    {
      //remove the cursor from it current position
      forceRemove();
      //reset the parent list
      parentList = list;
      //mark it as at the bottom
      atBottom = true;
      
      //insert it in front of the old first bottom cursor
      next = list.firstBottomCursor;
      if(next != null) next.previous = this;
      //mark this on as the first bottom cursor
      list.firstBottomCursor = this;      
    }    
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "moveToBottom");
  }
1180066
public void set(Rec fieldList) throws DBException
    {
        super.set(fieldList);
        Record record = (Record)fieldList;
        Iterator<BaseTable> iterator = this.getTables();
        while (iterator.hasNext())
        {
            BaseTable table = iterator.next();
            if ((table != null) && (table != this.getNextTable()))
            {
                if ((table.getRecord().getEditMode() == Constants.EDIT_IN_PROGRESS) || (table.getRecord().getEditMode() == Constants.EDIT_CURRENT))
                {
                    Record record2 = table.getRecord();
                    this.copyRecord(record2, record);
                    table.set(record2);
                }
                else if (table.getRecord().getEditMode() == Constants.EDIT_ADD)
                {   // Should have been in sync, but it is now!
                    Record record2 = table.getRecord();
                    boolean bIsAutoSequence = record2.setAutoSequence(false);
                    this.copyRecord(record2, record);
                    try {
                        table.add(record2);
                    } catch (DBException ex) {
                        throw ex;
                    } finally {
                        record2.setAutoSequence(bIsAutoSequence);
                    }
                }
            }
        }
    }
492599
public FieldList move(int iRelPosition) throws DBException
    {
        Record record = ((QueryRecord)m_record).moveTableQuery(iRelPosition);
        if (record != null)
            return (QueryRecord)m_record;
        else
            return null;
    }
424877
@Override
	public void relocate()
	{

		int w = 555, h = 235;
		int x = (this.getWidth() - w) / 2, y = (this.getHeight() - h) / 2;

		archiveScrollPane.setLocation(x, y);

		addArchiveButton.setLocation(x + 435, y + 10);
		removeArchiveButton.setLocation(x + 435, y + 40);

		encodingLabel.setLocation(x, y + 220);
		encodingField.setLocation(x + 210, y + 220);

		surrogatePanel.setLocation(x + 415, y + 85);

	}
12622
public int moveToIndex(int index)
    {
        int index2 = index;
        int iErrorCode = DBConstants.NORMAL_RETURN;
        if (m_bIncludeBlankOption)
        {
            if (index == 0)
                iErrorCode = DBConstants.ERROR_RETURN;
            index2--; // Offset by one
        }
        if (index == -1)
            iErrorCode = DBConstants.ERROR_RETURN;
        if (iErrorCode == DBConstants.NORMAL_RETURN)
        {
            if (index2 != -1)
            {
                try
                {
                    Record record = (Record)m_gridTable.get(index2);    //?, DONT_DISPLAY);   // DON'T Display, or you will be caught in a loop
                    if (record == null)
                        iErrorCode = DBConstants.END_OF_FILE;
                }
                catch( DBException e )
                {
                    iErrorCode = e.getErrorCode();
                }
            }
            else
                iErrorCode = DBConstants.ERROR_RETURN;  // Do an addNew
        }
        else        // This is usually selecting index 0 or -1!
        {
            m_record.initRecord(DBConstants.DISPLAY);  // Clear the fields!
            iErrorCode = DBConstants.NORMAL_RETURN;   // Clear fields = record 0
        }
        return iErrorCode;
    }
1320627
public void add(Rec record) throws DBException
    {
        if (this.getRecord().getEditMode() != Constants.EDIT_ADD)
            throw new DBException(Constants.INVALID_RECORD);
        m_record = (FieldList)record;
        this.fieldsToData(record);
        this.doAdd(record);
        this.setDataSource(null);
        this.getRecord().setEditMode(Constants.EDIT_NONE);
    }
75498
public FieldList moveThruMultipleTables(int iRelPosition) throws DBException
    { // ****ONLY TESTED FOR iRelPosition = +1****
        boolean bIsOpen = m_bIsOpen;
        if (!m_bIsOpen)
            this.open();
        BaseTable table = null;
        BaseTable tableNext = null;
        if (((m_iRecordStatus & DBConstants.RECORD_NEXT_PENDING) == DBConstants.RECORD_NEXT_PENDING)
            && (iRelPosition == DBConstants.NEXT_RECORD))
        {
            m_iRecordStatus = DBConstants.RECORD_NORMAL;
            tableNext = this.getCurrentTable();   // Special case - last call was hasNext()
        }
        else if (((m_iRecordStatus & DBConstants.RECORD_PREVIOUS_PENDING) == DBConstants.RECORD_PREVIOUS_PENDING)
            && (iRelPosition == DBConstants.PREVIOUS_RECORD))
        {
            m_iRecordStatus = DBConstants.RECORD_NORMAL;
            tableNext = this.getCurrentTable();   // Special case - last call was hasNext()
        }
        else
        { // First, make sure all the tables are opened and positioned on valid records.
            if ((!bIsOpen) || (iRelPosition == DBConstants.FIRST_RECORD))   // Need to use a different variable
            {   // If this is the first time thru, open and move to the first record
                Iterator<BaseTable> iterator = this.getTables();
                while (iterator.hasNext())
                {
                    table = iterator.next();
                    table.close();
                    table.getRecord().setKeyArea(this.getRecord().getDefaultOrder());
                    if (table.hasNext())
                    {
                        if (table != this.getCurrentTable())
                            table.move(+1);   // Move to first record
                        else
                            iRelPosition = +1;
                    }
                }
                m_bIsOpen = true; // Yes this file is now open.
            }
            if (!this.getCurrentTable().isEOF())
                this.getCurrentTable().move(iRelPosition);  // First, move the current table in the correct direction.
        // Now, compare the records to find the lowest key
            Iterator<BaseTable> iterator = this.getTables();
            while (iterator.hasNext())
            {
                table = iterator.next();
                if (!table.isEOF())
                {
                    if (tableNext == null)
                        tableNext = table;      // None here yet, this is the lowest
                    else
                    { // Now compare and get the lowest
                        int iCompareValue = 0;
                        int iKeyFields = table.getRecord().getKeyArea().getKeyFields() + DBConstants.MAIN_KEY_FIELD;
                        for (int iKeyFieldSeq = DBConstants.MAIN_KEY_FIELD; iKeyFieldSeq < iKeyFields; iKeyFieldSeq++)
                        {
                            BaseField fldCompare = table.getRecord().getKeyArea().getKeyField(iKeyFieldSeq).getField(DBConstants.FILE_KEY_AREA);
                            BaseField fldNext = tableNext.getRecord().getKeyArea().getKeyField(iKeyFieldSeq).getField(DBConstants.FILE_KEY_AREA);
                            iCompareValue = fldCompare.compareTo(fldNext);
                            if (this.getRecord().getKeyArea() != null)
                                if (this.getRecord().getKeyArea().getKeyField(iKeyFieldSeq) != null)
                                    if (this.getRecord().getKeyArea().getKeyOrder(iKeyFieldSeq) == DBConstants.DESCENDING)
                                iCompareValue = -iCompareValue;
                            if (iCompareValue != 0)
                                break;
                        }
                        if (iCompareValue < 0)
                            tableNext = table;      // This is the lowest so far.
                    }
                }
            }
        }
        if (tableNext == null)
        {
            Iterator<BaseTable> iterator = this.getTables();
            while (iterator.hasNext())
            {   // If this table is suppose to be PAST EOF, make sure all the records are too.
                table = iterator.next();
                if (iRelPosition == DBConstants.NEXT_RECORD)
                    if (table.isEOF())
                        table.move(+1);
            }
            return null;
        }
        this.setCurrentTable(tableNext);    // Never allow currentTable to be null.
        Record record = tableNext.getRecord();
        for (int iFieldSeq = DBConstants.MAIN_FIELD; iFieldSeq < record.getFieldCount(); ++iFieldSeq)
        {
//?         if (bDisplayOption)
            record.getField(iFieldSeq).displayField();      // Display this field
        }
        return record;
    }
707128
public FieldList setHandle(Object bookmark, int iHandleType) throws DBException
    {
        if (this.doSetHandle(bookmark, iHandleType))
            return this.getRecord();
        else
            return null;
    }
1287488
public void doSet(Rec record) throws DBException
    {
        try   {
            m_objLastModBookmark = null;
            m_tableRemote.set(this.getDataSource(), record.getOpenMode());
        } catch (RemoteException ex) {
            throw new DBException(ex.getMessage());
        }
    }
750356
public void doSet(Record record) throws DBException
    {
        try   {
            m_pTable.set(this);
        } catch (DBException ex)    {
            throw DatabaseException.toDatabaseException(ex);
        }
    }
408642
public void addNew() throws DBException
    {
        this.getRecord().setEditMode(Constants.EDIT_NONE);
        m_objectID = null;
        m_dataSource = null;
        try   {
            this.doAddNew();
            m_iRecordStatus = DBConstants.RECORD_NEW;
        } catch (DBException ex)   {
            throw ex;
        }
        this.getRecord().setEditMode(Constants.EDIT_ADD);   // I do this before the handleNewRecord behaviors do anything
        this.getRecord().handleNewRecord();   // Display Fields
    }
411333
public void run()
    {

        String strURL = this.getProperty(DBParams.URL);
        String strOut = this.getProperty("out");
        
        this.moveThisFile(strURL, strOut);
    }
219541
public void doSet(Rec record) throws DBException
    {
        super.doSet(record);
        if (m_arrayCache != null)
            if (m_iLogicalIndex != NO_INDEX)
            {
                m_arrayCache.set(m_iLogicalIndex, this.getDataSource());    // Show the current record as deleted.
            }
    }
144062
public void doAdd(Record record) throws DBException
    {
        record = this.moveRecordToBase(record);

        int iOpenMode = record.getOpenMode();
        RecordChangedHandler recordChangeListener = (RecordChangedHandler)record.getListener(RecordChangedHandler.class);
        Object[] rgobjEnabledFields = record.setEnableFieldListeners(false);
        boolean[] rgbEnabled = record.setEnableListeners(false);
        if (recordChangeListener != null)
        	recordChangeListener.setEnabledListener(true);	// I may need this listener (for an update) to do the update =ID AND =LastChangeDate
        
        try {
            record.setOpenMode(0);  // Normal add
            this.getNextTable().add(record);
        } catch (DBException ex) {
            throw ex;
        } finally {
            record.setOpenMode(iOpenMode);
            record.setEnableListeners(rgbEnabled);
            record.setEnableFieldListeners(rgobjEnabledFields);
        }
    }
130883
public void restorePosition() {
		RecordId rid1 = savedPosition.get(0);
		RecordId rid2 = savedPosition.get(1);
		s1.moveToRecordId(rid1);
		if (rid2 != null)
			s2.moveToRecordId(rid2);
	}