Emits the current column changed signal.
        
        :param      column | <orb.Column> || None
179990
def emitSchemaColumnChanged(self, column):
        
        edit = self.lineEdit()
        if edit:
            edit.setText(self.navigator().currentSchemaPath())
            
        if not self.signalsBlocked():
            self.schemaColumnChanged.emit(column)
834755
def hearing(self, column=None, value=None, **kwargs):
        
        return self._resolve_call('PCS_EVIDENTIARY_HEARING_EVENT', column,
                                  value, **kwargs)
1353202
public function changedColumnGet($column)
	{
		if( $this->recordExists() && $this->_changedColumnAccess($column) )
		{
			return $this->changeRecordData[$column];
		}
		else
		{
			return null;
		}
	}
910601
def emitDataChanged(self, regItem):
        
        #self.sourceModel().emitDataChanged(regItem) # Does this work?
        leftIndex = self.indexFromItem(regItem, col=0)
        rightIndex = self.indexFromItem(regItem, col=-1)
        self.dataChanged.emit(leftIndex, rightIndex)
1111657
def emitCurrentChanged(self):
        
        if not self.signalsBlocked():
            self.currentIndexChanged.emit(self.currentIndex())
            self.currentUrlChanged.emit(self.currentUrl())
            
            self.canGoBackChanged.emit(self.canGoBack())
            self.canGoForwardChanged.emit(self.canGoForward())
1371587
private synchronized void fireStatusUpdated(TableRowProgressMonitor source) {
    int row = monitors.indexOf(source);
    if (row >= 0) {
      fireTableCellUpdated(row, STATUS_COLUMN);
    }
  }
687931
def alter_change_column(self, table, column, field):
        """"""
        return self._update_column(table, column, lambda a, b: b)
1228462
def go_to_column(self, column):
        

        cursor = self.textCursor()
        cursor.setPosition(cursor.block().position() + column)
        self.setTextCursor(cursor)
        return True
574978
def _property_change_event_handler(self, signal, transport, *args):
        
        current_state = self.source.State
        if (self.state == 'connected' and current_state == 'playing'):
            self._acquire_media_transport(transport, 'r')
        elif (self.state == 'playing' and current_state == 'connected'):
            self._release_media_transport(transport, 'r')
        self.state = current_state
399412
def _updateColumnValues(self, index, hidden):
        
        if hidden or not self.isVisible():
            return
        
        column = self.columnOf(index)
        if not column in self._loadedColumns:
            self._loadedColumns.add(column)
            
            records = self.collectRecords()
            self.loadColumnsRequested.emit(records, column)
650691
def addColumn(self, column):
        
        column.setSchema(self)
        self.__columns[column.name()] = column
139475
def fire_column_event eve
      require 'canis/core/include/ractionevent'
      aev = TextActionEvent.new self, eve, get_column(@column_pointer.current_index), @column_pointer.current_index, @column_pointer.last_index
      fire_handler eve, aev
    end
1240472
def update_col(self, column_name, series):
        
        logger.debug('updating column {!r} in table {!r}'.format(
            column_name, self.name))
        self.local[column_name] = series
726033
private void updateWorkTimeUnit(FastTrackColumn column)
   {
      if (m_workTimeUnit == null && isWorkColumn(column))
      {
         int value = ((DurationColumn) column).getTimeUnitValue();
         if (value != 1)
         {
            m_workTimeUnit = FastTrackUtility.getTimeUnit(value);
         }
      }
   }
153402
public function changedColumnIs($column)
	{
		if( !$this->recordExists() )
		{
			return true;
		}
		elseif( $this->_recordAccess($column) && $this->_changedColumnAccess($column) )
		{
			return $this->recordColumnGet($column) != $this->changeRecordData[$column];
		}
		else
		{
			return true;
		}
	}
698928
def change_column(self, name, options):
        
        column = self.get_column(name)
        column.set_options(options)

        return self
910740
def _add(self, column):
        
        columns_for_table = self.data.setdefault(column.es_index, {})
        existing_columns = columns_for_table.setdefault(column.name, [])

        for canonical in existing_columns:
            if canonical is column:
                return None
            if canonical.es_type == column.es_type:
                if column.last_updated > canonical.last_updated:
                    for key in Column.__slots__:
                        old_value = canonical[key]
                        new_value = column[key]
                        if new_value == None:
                            pass  # DO NOT BOTHER CLEARING OLD VALUES (LIKE cardinality AND paritiions)
                        elif new_value == old_value:
                            pass  # NO NEED TO UPDATE WHEN NO CHANGE MADE (COMMON CASE)
                        else:
                            canonical[key] = new_value
                return canonical
        existing_columns.append(column)
        return column