Record the current active L2 cells as the representation for 'objectName'.
330438
def _saveL2Representation(self, objectName):
    
    self.objectL2Representations[objectName] = self.getL2Representations()

    try:
      objectIndex = self.objectNameToIndex[objectName]
    except KeyError:
      # Grow the matrices as needed.
      if self.objectNamesAreIndices:
        objectIndex = objectName
        if objectIndex >= self.objectL2RepresentationsMatrices[0].nRows():
          for matrix in self.objectL2RepresentationsMatrices:
            matrix.resize(objectIndex + 1, matrix.nCols())
      else:
        objectIndex = self.objectL2RepresentationsMatrices[0].nRows()
        for matrix in self.objectL2RepresentationsMatrices:
          matrix.resize(matrix.nRows() + 1, matrix.nCols())

      self.objectNameToIndex[objectName] = objectIndex

    for colIdx, matrix in enumerate(self.objectL2RepresentationsMatrices):
      activeCells = self.L2Columns[colIdx]._pooler.getActiveCells()
      matrix.setRowFromSparse(objectIndex, activeCells,
                              np.ones(len(activeCells), dtype="float32"))
1093441
def getLocationRepresentation(self):
    
    activeCells = np.array([], dtype="uint32")

    totalPrevCells = 0
    for module in self.L6aModules:
      activeCells = np.append(activeCells,
                              module.getActiveCells() + totalPrevCells)
      totalPrevCells += module.numberOfCells()

    return activeCells
1258249
function createBasicCell(rowIndex, colIndex, nodeName) {
  return {
    nodeName: nodeName || 'TD',
    colspan: 1,
    rowspan: 1,
    content: BASIC_CELL_CONTENT,
    elementIndex: {
      rowIndex,
      colIndex
    }
  };
}
1066599
def record_rename(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/rename' % object_id, input_params, always_retry=always_retry, **kwargs)
1016560
function(cell) {
    var elCell = this.getTdEl(cell);

    if(elCell) {
        // Make sure previous cell is unhighlighted
        if(this._elLastHighlightedTd) {
            this.unhighlightCell(this._elLastHighlightedTd);
        }

        var oRecord = this.getRecord(elCell);
        var sColumnKey = this.getColumn(elCell.cellIndex).getKey();
        Dom.addClass(elCell,DT.CLASS_HIGHLIGHTED);
        this._elLastHighlightedTd = elCell;
        this.fireEvent("cellHighlightEvent", {record:oRecord, column:this.getColumn(elCell.cellIndex), key:this.getColumn(elCell.cellIndex).getKey(), el:elCell});
        return;
    }
}
923619
def updateObj(self, event):
        """"""

        name = self.objList.get("active")
        self.SearchVar.set(name)
        self.object_info.set(str(self.kbos.get(name, '')))
        return
824009
function(){
		var pos = this.getpos(0);
		if(this.prevPos.equals(pos)){ return;}

		var cell = this.prevPos.getc();
		if(!cell.isnull){
			if(cell.qnum!==-1){
				var dir = this.prevPos.getdir(pos,2);
				if(dir!==cell.NDIR){
					cell.setQdir(cell.qdir!==dir?dir:0);
					cell.draw();
				}
			}
		}
		this.prevPos = pos;
	}
560868
def _update_video_volume_cell_attributes(self, key):
        """"""

        try:
            video_cell_panel = self.grid_renderer.video_cells[key]
        except KeyError:
            return

        old_video_volume = self.code_array.cell_attributes[key]["video_volume"]
        new_video_volume = video_cell_panel.volume

        if old_video_volume == new_video_volume:
            return

        selection = Selection([], [], [], [], [key])

        self.actions.set_attr("video_volume", new_video_volume, selection)
639319
def displayName( self ):
        
        if ( not self._displayName ):
            return projex.text.pretty(self.objectName())
        return self._displayName
331277
def record_from_current_or_find(klass, id, current)
      if current.is_a?(ActiveRecord::Base) && current.id.to_s == id
        # modifying the current object of a singular association
        current
      elsif current.respond_to?(:any?) && current.any? { |o| o.id.to_s == id }
        # modifying one of the current objects in a plural association
        current.detect { |o| o.id.to_s == id }
      else # attaching an existing but not-current object
        klass.find(id)
      end
    end
266435
def object_build_class(node, member, localname):
    """"""
    basenames = [base.__name__ for base in member.__bases__]
    return _base_class_object_build(node, member, basenames, localname=localname)
857420
def _get_column_cell_val(self, obj, column):
        
        name = column['name']
        return self._get_formatted_val(obj, name, column)
62191
def cell(name, model, options = {}, &block)
      options = { context: { current_user: current_user } }.deep_merge(options)

      super(name, model, options, &block)
    end
944338
function _storeObject($elObj) 
    {
        $name = $elObj->name;
        if(is_object($this->_currentGroup) && $elObj->type != 'group') {
            $this->_currentGroup->elements[] = $elObj;
        } elseif (isset($this->_currentSection)) {
            $this->_obj->sections[$this->_currentSection]->elements[] = $elObj;
        } else {
            $this->_obj->elements[] = $elObj;
        }
    }
859659
def objects_to_record(self):
        """"""

        o = self.get_object()

        o.about = self._bundle.metadata.about
        o.identity = self._dataset.identity.ident_dict
        o.names = self._dataset.identity.names_dict
        o.contacts = self._bundle.metadata.contacts

        self.set_object(o)
1085427
def _object_name_html(self):
        
        if self.presently.exists:
            url = self.url()
            return "<a href=\"%s\">%s</a>" % (url,
                                              unicode(self.get_object()),)
        else:
            return "(deleted)"
455466
def active_scalar_info(self):
        """"""
        if not hasattr(self, '_active_scalar_info'):
            self._active_scalar_info = [POINT_DATA_FIELD, None] # field and name
        field, name = self._active_scalar_info

        # rare error where scalar name isn't a valid scalar
        if name not in self.point_arrays:
            if name not in self.cell_arrays:
                name = None

        if name is None:
            if self.n_scalars < 1:
                return field, name
            # find some array in the set field
            parr = self.GetPointData().GetArrayName(0)
            carr = self.GetCellData().GetArrayName(0)
            if parr is not None:
                self._active_scalar_info = [POINT_DATA_FIELD, parr]
                self.GetPointData().SetActiveScalars(parr)
            elif carr is not None:
                self._active_scalar_info = [CELL_DATA_FIELD, carr]
                self.GetCellData().SetActiveScalars(carr)
        return self._active_scalar_info