Returns the header for a section (row or column depending on orientation).
            Reimplemented from QAbstractTableModel to make the headers start at 0.
549781
def headerData(self, section, orientation, role):
        
        if role == Qt.DisplayRole:
            if self._separateFieldOrientation == orientation:

                nFields = len(self._fieldNames)
                varNr = section // nFields
                fieldNr = section % nFields
                header = str(varNr) + ' : ' if self._numbersInHeader else ''
                header += self._fieldNames[fieldNr]
                return header
            else:
                return str(section)
        else:
            return None
608064
def header(self, item0, *items):
        
        self.txt(item0)
        at_x = None
        for item in items:
            if at_x is None:
                at_x = item
            else:
                self.txt(item, at_x=at_x)
                at_x = None
591792
def _get_header(self, header):
        
        if header is None:
            html = self.header()
        else:
            html = header
        return html
484281
private Color getSectionColor(SectionHeader header) {
		// color is based on section number
		int nr = header.getNumber();
		Color sectionColor = colorMap.get(SECTION_START);
		// modify the color section number times
		for (int i = 1; i < nr; i++) {
			sectionColor = variate(sectionColor);
		}
		return sectionColor;
	}
873960
def set_header_visibility(self, column=False, row=False):
        
        if row:    self._widget.verticalHeader().show()
        else:      self._widget.verticalHeader().hide()

        if column: self._widget.horizontalHeader().show()
        else:      self._widget.horizontalHeader().hide()

        return self
521204
def get_status_cols(self, section):
        
        colours = dict()
        for s_name in self.fastqc_data:
            status = self.fastqc_data[s_name]['statuses'].get(section, 'default')
            colours[s_name] = self.status_colours[status]
        return colours
1166706
function(oTable) {
			var oInfo = TableUtils.getFocusedItemInfo(oTable);
			return oInfo.row - TableUtils.getHeaderRowCount(oTable);
		}
1183925
def calculate_header
            headers = []
            height = 0
            @current_groups.each do |field, current_value|
                identifier_field = @sections[:groups][field.to_sym][:settings][:identifier_field] || nil
                value = (!@record.class.reflect_on_association(field).nil? and !identifier_field.nil?) ? @record.send(field.to_sym).send(identifier_field) : @record.send(field)

                if value != current_value
                    reset_groups_values field

                    headers << field.to_sym
                    height += @sections[:groups][field.to_sym][:settings][:height] + @sections[:groups][field.to_sym][:settings][:posY]

                    @current_groups[field] = value
                end
            end unless @current_groups.empty?

            [headers, height]
        end
68366
public Optional<SectionHeader> maybeGetSectionHeaderByRVA(long rva) {
        List<SectionHeader> headers = table.getSectionHeaders();
        for (SectionHeader header : headers) {
            VirtualLocation vLoc = getVirtualSectionLocation(header);
            if (addressIsWithin(vLoc, rva)) {
                return Optional.of(header);
            }
        }
        return Optional.absent();
    }
992847
def _GetRow(self, columns=None):
        """"""

        row = self._table[self._row_index]
        if columns:
            result = []
            for col in columns:
                if col not in self.header:
                    raise TableError("Column header %s not known in table." % col)
                result.append(row[self.header.index(col)])
            row = result
        return row
177744
public String getHeadings(int i) {
    if (DataTable_Type.featOkTst && ((DataTable_Type)jcasType).casFeat_headings == null)
      jcasType.jcas.throwFeatMissing("headings", "ch.epfl.bbp.uima.types.DataTable");
    jcasType.jcas.checkArrayBounds(jcasType.ll_cas.ll_getRefValue(addr, ((DataTable_Type)jcasType).casFeatCode_headings), i);
    return jcasType.ll_cas.ll_getStringArrayValue(jcasType.ll_cas.ll_getRefValue(addr, ((DataTable_Type)jcasType).casFeatCode_headings), i);}
495595
def headers(self):
        
        if self._headers is None:
            query = CellQuery()
            query.max_row = '1'
            feed = self._service.GetCellsFeed(self._ss.id, self.id,
                                              query=query)
            self._headers = feed.entry
        return [normalize_header(h.cell.text) for h in self._headers]
982299
def header(self, sheet, name):
        

        header = sheet.row(0)
        for i, column in enumerate(self.headers[name]):
            header.write(i, self.headers[name][i])
950102
def _getPaddingDataToSectionOffset(self):
        
        start = self._getPaddingToSectionOffset()
        end = self.sectionHeaders[0].pointerToRawData.value - start
        return self._data[start:start+end]
1236997
def column(self, source_header_or_pos):
        
        for c in self.columns:
            if c.source_header == source_header_or_pos:
                assert c.st_vid == self.vid
                return c
            elif c.position == source_header_or_pos:
                assert c.st_vid == self.vid
                return c

        else:
            return None
1271705
def getheader(self, header, default=None):
        '''
        
        '''
        if isinstance(header, str):
            return self.headers.get(header.lower(), default)
        return self.__rawheaders.get(header, default)
583148
def headerData(self, index, orientation, role):
        
        d = self.declaration
        if orientation == Qt.Horizontal and role == Qt.DisplayRole:
            try:
                return d.horizontal_headers[index] \
                    if d.horizontal_headers else index
            except IndexError:
                return index
        elif orientation == Qt.Vertical and role == Qt.DisplayRole:
            try:
                return d.vertical_headers[index] \
                    if d.vertical_headers else index
            except IndexError:
                return index
        return None