Prompts the user to edit the inputed record.
        
        :param      record | <orb.Table>
                    parent | <QWidget>
        
        :return     <bool> | accepted
976728
def edit( cls, record, parent = None, uifile = '', commit = True ):
        
        # create the dialog
        dlg = QDialog(parent)
        dlg.setWindowTitle('Edit %s' % record.schema().name())
        
        # create the widget
        cls    = record.schema().property('widgetClass', cls)
        
        widget = cls(dlg)
        
        if ( uifile ):
            widget.setUiFile(uifile)
        
        widget.setRecord(record)
        widget.layout().setContentsMargins(0, 0, 0, 0)
        
        # create buttons
        opts = QDialogButtonBox.Save | QDialogButtonBox.Cancel
        btns = QDialogButtonBox(opts, Qt.Horizontal, dlg)
        
        # create layout
        layout = QVBoxLayout()
        layout.addWidget(widget)
        layout.addWidget(btns)
        
        dlg.setLayout(layout)
        dlg.adjustSize()
        
        # create connections
        #btns.accepted.connect(widget.save)
        btns.rejected.connect(dlg.reject)
        widget.saved.connect(dlg.accept)
        
        if ( dlg.exec_() ):
            if commit:
                result = widget.record().commit()
                if 'errored' in result:
                    QMessageBox.information(self.window(),
                                            'Error Committing to Database',
                                            result['errored'])
                    return False
            return True
        return False
923207
public void updateRecord(final ORecordInternal<?> record) {
    if (isEnabled() && record.getIdentity().getClusterId() != excludedCluster && record.getIdentity().isValid()) {
      underlying.lock(record.getIdentity());
      try {
        if (underlying.get(record.getIdentity()) != record)
          underlying.put(record);
      } finally {
        underlying.unlock(record.getIdentity());
      }
    }

    secondary.updateRecord(record);
  }
564926
public void addRecord(Rec record, boolean bMainQuery)
    {
        if (record == null)
            return;
        if (this.contains(record))
        {     // Don't add this twice.
            if (!bMainQuery)
                return;
            this.removeRecord(record);  // Change order
        }
        if (bMainQuery)
            this.insertElementAt(record, 0);
        else
            this.addElement(record);
    }
1327962
def _update_record(self, identifier, rtype=None, name=None, content=None):
        
        result = False

        # TODO: some providers allow content-based updates without supplying an
        # ID, and therefore `identifier` is here optional. If we don't receive
        # an ID, look it up.
        if not identifier and rtype and name:
            records = self._list_records(rtype, name)
            if len(records) == 1:
                identifier = records[0]["id"]

        if identifier and content:
            with localzone.manage(self.filename, self.origin, autosave=True) as zone:
                if zone.update_record(identifier, content):  # pylint: disable=no-member
                    result = True

        LOGGER.debug("update_record: %s", result)
        return result
1292423
def delete_record(self, record):
        
        self.children.remove(record.resource)
        record.delete()
1269522
public void init(Object parent, Object record)
    {
        super.init(parent, record);

        this.addSubPanels(this);
        
        TraversableGridPolicy.addGridTraversalPolicy(this.getControl(), this);
    }
256534
function inputRecord (type, record) {
  const clone = {};
  const recordTypes = this.recordTypes;
  const primaryKey = this.keys.primary;
  const isArrayKey = this.keys.isArray;
  const generateId = this.options.generateId;
  const fields = recordTypes[type];

  // ID business.
  const id = record[primaryKey];
  clone[idKey] = id ? id : generateId(type);

  for (const field in record) {
    if (field === primaryKey) continue;
    clone[field] = record[field];
  }

  for (const field of Object.getOwnPropertyNames(fields))
    if (!(field in record))
      clone[field] = fields[field][isArrayKey] ? [] : null;

  return clone;
}
1372904
def set_record(self, record, **kw):
        

        if isstring(record):
            card = FITSCard(record)
            self.update(card)

            self.verify()

        else:

            if isinstance(record, FITSRecord):
                self.update(record)
            elif isinstance(record, dict):
                if 'name' in record and 'value' in record:
                    self.update(record)

                elif 'card_string' in record:
                    self.set_record(record['card_string'])

                else:
                    raise ValueError('record must have name,value fields '
                                     'or a card_string field')
            else:
                raise ValueError("record must be a string card or "
                                 "dictionary or FITSRecord")
536192
public int doRecordChange(FieldInfo field, int iChangeType, boolean bDisplayOption)
    { // Read a valid record
        int iErrorCode = super.doRecordChange(field, iChangeType, bDisplayOption);      // Initialize the record
        if (iErrorCode == DBConstants.NORMAL_RETURN)
        {
            if ((iChangeType == DBConstants.ADD_TYPE)
                || (iChangeType == DBConstants.UPDATE_TYPE)
                || (iChangeType == DBConstants.DELETE_TYPE))
                    this.updateListener(null);  // Stop listening
            if (iErrorCode == DBConstants.AFTER_REQUERY_TYPE)
//?             || (iErrorCode == DBConstants.SELECT_TYPE))
            {
    //+         ???
            }
        }
        return iErrorCode;
    }
985436
def emit(self, record):
        
        # if we've already processed this record, ignore it
        if record in self._recordQueue:
            return
        
        name = record.name
        lvl = self.loggerLevel(name)
        
        # don't process this log
        if lvl > record.levelno:
            return
        
        self._recordQueue.insert(0, record)
        self._recordQueue = self._recordQueue[:10]
        
        # emit the change
        super(XLogRecordHandler, self).emit(record)
1113147
def emit(self, record):
        
        # if we've already processed this record, ignore it
        if record in self._recordQueue:
            return
        
        if self._activeLevels and not record.levelno in self._activeLevels:
            return
        
        name = record.name
        lvl = self.loggerLevel(name)
        
        # don't process this log
        if lvl > record.levelno:
            return
        
        self._recordQueue.insert(0, record)
        self._recordQueue = self._recordQueue[:10]
        
        # emit the change
        super(XLoggerWidgetHandler, self).emit(record)
402977
def setRecord( self, record ):
        
        self._record = record
        
        if ( not record ):
            return
        
        self.setModel(record.__class__)
        schema = self.model().schema()
        
        # set the information
        column_edits = self.findChildren(XOrbColumnEdit)
        for widget in column_edits:
            columnName  = widget.columnName()
            column      = schema.column(columnName)
            
            if ( not column ):
                logger.warning('%s is not a valid column of %s.' % \
                               (columnName, schema.name()))
                continue
                
            # update the values
            widget.setValue(record.recordValue(columnName))
433305
def create(record)
      result = self.class.post(worksheet_url,
        :body => { "fields" => record.fields }.to_json,
        :headers => { "Content-type" => "application/json" }).parsed_response

      check_and_raise_error(result)

      record.override_attributes!(result_attributes(result))
      record
    end
535352
def record(self):
        # type: () -> bytes
        '''
        
        '''
        if not self._initialized:
            raise pycdlibexception.PyCdlibInternalError('RE record not yet initialized!')

        return b'RE' + struct.pack('=BB', RRRERecord.length(), SU_ENTRY_VERSION)
796649
def on_records(self, records):
        
        handler = self.handlers.get("on_records")
        if callable(handler):
            handler(records)
290740
function(record, oArgs){
		var itemContainer = oArgs.editor.getTdEl().childNodes[0];
		// Add CSS
		Dom.addClass(itemContainer, "inputEx-dtInPlaceEdit-onModifyItem");
		this.itemModifiedEvt.fire(record);
	}
1243800
public boolean processThisRecord(Record record)
    {
        if (record != null)
        {   // Delete all the records
            this.disableAllListeners(record);
            if ((record.getDatabaseType() & (DBConstants.BASE_TABLE_CLASS | DBConstants.SHARED_TABLE)) == (DBConstants.BASE_TABLE_CLASS | DBConstants.SHARED_TABLE))
                this.initSharedRecord(record);
            record.close();
            try {
                while (record.hasNext())
                {
                    record.next();
                    record.edit();
                    record.remove();
                }
            } catch (DBException e) {
                e.printStackTrace();
            }
        }
        return true;
    }