QTable

NAME

SYNOPSIS

Inherits QScrollView.

Inherited by QDataTable.

Public Members

Public Slots

Signals

Properties

Protected Members

Protected Slots

DESCRIPTION

QTable is easy to use, although it does have a large API because of the comprehensive functionality that it provides. QTable includes functions for manipulating headers, rows and columns, cells and selections. QTable also provides in-place editing and drag and drop, as well as a useful set of signals. QTable efficiently supports very large tables, for example, tables one million by one million cells are perfectly possible. QTable is economical with memory, using none for unused cells.

    QTable *table = new QTable( 100, 250, this );


    table->setPixmap( 3, 2, pix );


    table->setText( 3, 2, "A pixmap" );

The first line constructs the table specifying its size in rows and columns. We then insert a pixmap and some text into the same cell, with the pixmap appearing to the left of the text. QTable cells can be populated with QTableItems, QComboTableItems or by QCheckTableItems. By default a vertical header appears at the left of the table showing row numbers and a horizontal header appears at the top of the table showing column numbers. (The numbers displayed start at 1, although row and column numbers within QTable begin at 0.)

If you want to use mouse tracking call setMouseTracking( TRUE ) on the viewport; (see QScrollView).

<center>

</center>  

Headers

Header labels are indexed via their section numbers. Note that the default behavior of QHeader regarding section numbers is overriden for QTable. See the explanation below in the Rows and Columns section in the discussion of moving columns and rows.  

Rows and Columns

Rows and columns can be hidden and shown with hideRow(), hideColumn(), showRow() and showColumn(). New rows and columns are inserted using insertRows() and insertColumns(). Additional rows and columns are added at the bottom (rows) or right (columns) if you set setNumRows() or setNumCols() to be larger than numRows() or numCols(). Existing rows and columns are removed with removeRow() and removeColumn(). Multiple rows and columns can be removed with removeRows() and removeColumns().

Rows and columns can be set to be moveable using rowMovingEnabled() and columnMovingEnabled(). The user can drag them to reorder them holding down the Ctrl key and dragging the mouse. For performance reasons, the default behavior of QHeader section numbers is overridden by QTable. Currently in QTable, when a row or column is dragged and reordered, the section number is also changed to its new position. Therefore, there is no difference between the section and the index fields in QHeader. The QTable QHeader classes do not provide a mechanism for indexing independently of the user interface ordering.

The table can be sorted using sortColumn(). Users can sort a column by clicking its header if setSorting() is set to TRUE. Rows can be swapped with swapRows(), columns with swapColumns() and cells with swapCells().

For editable tables (see setReadOnly()) you can set the read-only property of individual rows and columns with setRowReadOnly() and setColumnReadOnly(). (Whether a cell is editable or read-only depends on these settings and the cell's QTableItem::EditType.)

The row and column which have the focus are returned by currentRow() and currentColumn() respectively.

Although many QTable functions operate in terms of rows and columns the indexOf() function returns a single integer identifying a particular cell.  

Cells

There are two approaches to populating the table's cells. The first and simplest approach is to use QTableItems or QTableItem subclasses. The second approach doesn't use QTableItems at all which is useful for very large sparse tables but requires you to reimplement a number of functions. We'll look at each approach in turn.

To put a string in a cell use setText(). This function will create a new QTableItem for the cell if one doesn't already exist, and displays the text in it. By default the table item's widget will be a QLineEdit. A pixmap may be put in a cell with setPixmap(), which also creates a table item if required. A cell may contain both a pixmap and text; the pixmap is displayed to the left of the text. Another approach is to construct a QTableItem or QTableItem subclass, set its properties, then insert it into a cell with setItem().

If you want cells which contain comboboxes use the QComboTableItem class. Similarly if you require cells containing checkboxes use the QCheckTableItem class. These table items look and behave just like the combobox or checkbox widgets but consume far less memory.

        for ( int j = 0; j < numRows; ++j )


            table.setItem( j, 1, new QCheckTableItem( &table, "Check me" ) );

QTable takes ownership of its QTableItems and will delete them when the table itself is destroyed. You can take ownership of a table item using takeItem() which you use to move a cell's contents from one cell to another, either within the same table, or from one table to another. (See also, swapCells()).

In-place editing of the text in QTableItems, and the values in QComboTableItems and QCheckTableItems works automatically. Cells may be editable or read-only, see QTableItem::EditType. If you want fine control over editing see beginEdit() and endEdit().

The contents of a cell can be retrieved as a QTableItem using item(), or as a string with text() or as a pixmap (if there is one) with pixmap(). A cell's bounding rectangle is given by cellGeometry(). Use updateCell() to repaint a cell, for example to clear away a cell's visual representation after it has been deleted with clearCell(). The table can be forced to scroll to show a particular cell with ensureCellVisible(). The isSelected() function indicates if a cell is selected.

It is possible to use your own widget as a cell's widget using setCellWidget(), but subclassing QTableItem might be a simpler approach. The cell's widget (if there is one) can be removed with clearCellWidget().

<h4> Large tables </h4>

For large, sparse, tables using QTableItems or other widgets is inefficient. The solution is to draw the cell as it should appear and to create and destroy cell editors on demand.

This approach requires that you reimplement various functions. Reimplement paintCell() to display your data, and createEditor() and setCellContentFromEditor() to support in-place editing. It is very important to reimplement resizeData() to have no functionality, to prevent QTable from attempting to create a huge array. You will also need to reimplement item(), setItem(), takeItem(), clearCell(), and insertWidget(), cellWidget() and clearCellWidget(). In almost every circumstance (for sorting, removing and inserting columns and rows, etc.), you also need to reimplement swapRows(), swapCells() and swapColumns(), including header handling.

If you represent active cells with a dictionary of QTableItems and QWidgets, i.e. only store references to cells that are actually used, many of the functions can be implemented with a single line of code. (See the table/bigtable/main.cpp example.)

For more information on cells see the QTableItem documenation.  

Selections

QTable's support many simultaneous selections. You can programmatically select cells with addSelection(). The number of selections is given by numSelections(). The current selection is returned by currentSelection(). You can remove a selection with removeSelection() and remove all selections with clearSelection(). Selections are QTableSelection objects.

To easily add a new selection use selectCells(), selectRow() or selectColumn().

Alternatively, use addSelection() to add new selections using QTableSelection objects. The advantage of using QTableSelection objects is that you can call QTableSelection::expandTo() to resize the selection and can query and compare them.

The number of selections is given by numSelections(). The current selection is returned by currentSelection(). You can remove a selection with removeSelection() and remove all selections with clearSelection().  

Signals

See also Advanced Widgets.  

Member Type Documentation

QTable::EditMode

QTable::NotEditing - No cell is currently being edited.

QTable::Editing - A cell is currently being edited. The editor was initialised with the cell's contents.

QTable::Replacing - A cell is currently being edited. The editor was not initialised with the cell's contents.

QTable::FocusStyle

QTable::FollowStyle - The current cell is drawn according to the current style and the cell's background is also drawn selected, if the current cell is within a selection

QTable::SpreadSheet - The current cell is drawn as in a spreadsheet. This means, it is signified by a black rectangle around the cell, and the background of the current cell is always drawn with the widget's base color - even when selected.

QTable::SelectionMode

QTable::NoSelection - No cell can be selected by the user.

QTable::Single - The user may only select a single range of cells.

QTable::Multi - The user may select multiple ranges of cells.

QTable::SingleRow - The user may select one row at once.

QTable::MultiRow - The user may select multiple rows.

MEMBER FUNCTION DOCUMENTATION

QTable::QTable ( QWidget * parent = 0, const char * name = 0 )

Call setNumRows() and setNumCols() to set the table size before populating the table if you're using QTableItems.

See also QWidget::clearWFlags() and Qt::WidgetFlags.  

QTable::QTable ( int numRows, int numCols, QWidget * parent = 0, const char * name = 0 )

If you're using QTableItems to populate the table's cells, you can create QTableItem, QComboTableItem and QCheckTableItem items and insert them into the table using setItem(). (See the notes on large tables for an alternative to using QTableItems.)

See also QWidget::clearWFlags() and Qt::WidgetFlags.  

QTable::~QTable ()

void QTable::activateNextCell () [virtual protected]

The default behaviour is to move from top to bottom, i.e. move to the cell beneath the cell being edited. Reimplement this function if you want different behaviour, e.g. moving from left to right.  

int QTable::addSelection ( const QTableSelection & s ) [virtual]

Remember to call QTableSelection::init() and QTableSelection::expandTo() to make the selection valid (see also QTableSelection::isActive(), or use the QTableSelection(int,int,int,int) constructor).

See also numSelections, removeSelection(), and clearSelection().  

void QTable::adjustColumn ( int col ) [virtual slot]

See also adjustRow().

Example: regexptester/regexptester.cpp.

Reimplemented in QDataTable.  

void QTable::adjustRow ( int row ) [virtual slot]

See also adjustColumn().  

QWidget * QTable::beginEdit ( int row, int col, bool replace ) [virtual protected]

See also endEdit().  

QRect QTable::cellGeometry ( int row, int col ) const [virtual]

QRect QTable::cellRect ( int row, int col ) const [virtual]

See also cellGeometry().

Example: chart/setdataform.cpp.  

QWidget * QTable::cellWidget ( int row, int col ) const [virtual]

If you don't use QTableItems you may need to reimplement this function: see the notes on large tables.

See also clearCellWidget() and setCellWidget().

Example: chart/setdataform.cpp.  

void QTable::clearCell ( int row, int col ) [virtual]

If you don't use QTableItems you may need to reimplement this function: see the notes on large tables.  

void QTable::clearCellWidget ( int row, int col ) [virtual]

If you don't use QTableItems you may need to reimplement this function: see the notes on large tables.

This function deletes the widget at row, col. Note that the widget is not deleted immediately; instead QObject::deleteLater() is called on the widget to avoid problems with timing issues.

See also cellWidget() and setCellWidget().  

void QTable::clearSelection ( bool repaint = TRUE ) [slot]

See also removeSelection().  

void QTable::clicked ( int row, int col, int button, const QPoint & mousePos ) [signal]

See also Qt::ButtonState.

Example: chart/setdataform.cpp.  

int QTable::columnAt ( int x ) const [virtual]

See also columnPos() and rowAt().  

void QTable::columnClicked ( int col ) [virtual protected slot]

void QTable::columnIndexChanged ( int section, int fromIndex, int toIndex ) [virtual protected slot]

If you want to change the column order programmatically, call swapRows() or swapColumns();

See also QHeader::indexChange() and rowIndexChanged().  

bool QTable::columnMovingEnabled () const

int QTable::columnPos ( int col ) const [virtual]

See also columnAt() and rowPos().  

int QTable::columnWidth ( int col ) const [virtual]

See also setColumnWidth() and rowHeight().  

void QTable::columnWidthChanged ( int col ) [virtual protected slot]

void QTable::contentsDragEnterEvent ( QDragEnterEvent * e ) [virtual protected]

The focus is moved to the cell where the QDragEnterEvent occurred.

Reimplemented from QScrollView.  

void QTable::contentsDragLeaveEvent ( QDragLeaveEvent * e ) [virtual protected]

Reimplemented from QScrollView.  

void QTable::contentsDragMoveEvent ( QDragMoveEvent * e ) [virtual protected]

The focus is moved to the cell where the QDragMoveEvent occurred.

Reimplemented from QScrollView.  

void QTable::contentsDropEvent ( QDropEvent * e ) [virtual protected]

Reimplemented from QScrollView.  

void QTable::contextMenuRequested ( int row, int col, const QPoint & pos ) [signal]

QWidget * QTable::createEditor ( int row, int col, bool initFromCell ) const [virtual protected]

If initFromCell is TRUE, the editor is used to edit the current contents of the cell (so the editor widget should be initialized with this content). If initFromCell is FALSE, the content of the cell is replaced with the new content which the user entered into the widget created by this function.

The default functionality is as follows: if initFromCell is TRUE or the cell has a QTableItem and the table item's QTableItem::isReplaceable() is FALSE then the cell is asked to create an appropriate editor (using QTableItem::createEditor()). Otherwise a QLineEdit is used as the editor.

If you want to create your own editor for certain cells, implement a custom QTableItem subclass and reimplement QTableItem::createEditor().

If you are not using QTableItems and you don't want to use a QLineEdit as the default editor, subclass QTable and reimplement this function with code like this:

    QTableItem *i = item( row, col );


    if ( initFromCell || ( i && !i->isReplaceable() ) )


        // If we had a QTableItem ask the base class to create the editor


        return QTable::createEditor( row, col, initFromCell );


    else


        return ...(create your own editor)

If you reimplement this function return 0 for read-only cells. You will need to reimplement setCellContentFromEditor() to retrieve the data the user entered.

See also QTableItem::createEditor().  

int QTable::currEditCol () const [protected]

int QTable::currEditRow () const [protected]

void QTable::currentChanged ( int row, int col ) [signal]

Example: chart/setdataform.cpp.  

int QTable::currentColumn () const

See also currentRow().

Example: chart/setdataform.cpp.  

int QTable::currentRow () const

See also currentColumn().

Example: chart/setdataform.cpp.  

int QTable::currentSelection () const [virtual]

See also numSelections.  

void QTable::doubleClicked ( int row, int col, int button, const QPoint & mousePos ) [signal]

See also Qt::ButtonState.  

bool QTable::dragEnabled () const [slot]

See also setDragEnabled().  

QDragObject * QTable::dragObject () [virtual protected]

By default this function returns 0. You might reimplement it and create a QDragObject depending on the selected items.

See also dropped().  

void QTable::drawContents ( QPainter * p, int cx, int cy, int cw, int ch ) [virtual protected]

Additionally, drawContents() highlights the current cell.

Reimplemented from QScrollView.  

void QTable::dropped ( QDropEvent * e ) [signal]

e contains information about the drop.  

void QTable::editCell ( int row, int col, bool replace = FALSE ) [virtual slot]

If replace is TRUE the content of this cell will be replaced by the content of the editor when editing is finished, i.e. the user will be entering new data; otherwise the current content of the cell (if any) will be modified in the editor.

See also beginEdit().  

EditMode QTable::editMode () const [protected]

See also QTable::EditMode.  

void QTable::endEdit ( int row, int col, bool accept, bool replace ) [virtual protected]

If the cell is not being edited or accept is FALSE the function returns and the cell's contents are left unchanged.

If accept is TRUE the content of the editor must be transferred to the relevant cell. If replace is TRUE the current content of this cell should be replaced by the content of the editor (this means removing the current QTableItem of the cell and creating a new one for the cell). Otherwise (if possible) the content of the editor should just be set to the existing QTableItem of this cell.

setCellContentFromEditor() is called to replace the contents of the cell with the contents of the cell's editor.

Finally clearCellWidget() is called to remove the editor widget.

See also setCellContentFromEditor() and beginEdit().  

void QTable::ensureCellVisible ( int row, int col )

FocusStyle QTable::focusStyle () const

void QTable::hideColumn ( int col ) [virtual slot]

See also showColumn() and hideRow().  

void QTable::hideRow ( int row ) [virtual slot]

See also showRow() and hideColumn().  

QHeader * QTable::horizontalHeader () const

This header contains the column labels.

To modify a column label use QHeader::setLabel(), e.g.

        horizontalHeader()->setLabel( 0, tr( "File" ) );

See also verticalHeader(), setTopMargin(), and QHeader.

Examples:  

int QTable::indexOf ( int row, int col ) const [protected]

This is useful, for example, if you have a sparse table and want to use a QIntDict to map integers to the cells that are used.  

void QTable::insertColumns ( int col, int count = 1 ) [virtual slot]

See also insertRows() and removeColumn().  

void QTable::insertRows ( int row, int count = 1 ) [virtual slot]

See also insertColumns() and removeRow().  

void QTable::insertWidget ( int row, int col, QWidget * w ) [virtual protected]

If you don't use QTableItems you may need to reimplement this function: see the notes on large tables.  

bool QTable::isColumnHidden ( int col ) const [slot]

See also hideColumn() and isRowHidden().  

bool QTable::isColumnReadOnly ( int col ) const

Whether a cell in this column is editable or read-only depends on the cell's EditType, and this setting: see QTableItem::EditType.

See also setColumnReadOnly() and isRowReadOnly().  

bool QTable::isColumnSelected ( int col, bool full = FALSE ) const

If full is FALSE (the default), 'column is selected' means that at least one cell in the column is selected. If full is TRUE, then 'column is selected' means every cell in the column is selected.

See also isRowSelected() and isSelected().  

bool QTable::isColumnStretchable ( int col ) const [slot]

See also setColumnStretchable() and isRowStretchable().  

bool QTable::isEditing () const [protected]

See also QTable::EditMode.  

bool QTable::isReadOnly () const

bool QTable::isRowHidden ( int row ) const [slot]

See also hideRow() and isColumnHidden().  

bool QTable::isRowReadOnly ( int row ) const

Whether a cell in this row is editable or read-only depends on the cell's EditType, and this setting: see QTableItem::EditType.

See also setRowReadOnly() and isColumnReadOnly().  

bool QTable::isRowSelected ( int row, bool full = FALSE ) const

If full is FALSE (the default), 'row is selected' means that at least one cell in the row is selected. If full is TRUE, then 'row is selected' means every cell in the row is selected.

See also isColumnSelected() and isSelected().  

bool QTable::isRowStretchable ( int row ) const [slot]

See also setRowStretchable() and isColumnStretchable().  

bool QTable::isSelected ( int row, int col ) const

See also isRowSelected() and isColumnSelected().  

QTableItem * QTable::item ( int row, int col ) const [virtual]

If row or col are out of range or no content has been set for this cell, item() returns 0.

If you don't use QTableItems you may need to reimplement this function: see the notes on large tables.

See also setItem().

Example: regexptester/regexptester.cpp.  

int QTable::numCols () const [virtual]

Reimplemented in QDataTable.  

int QTable::numRows () const [virtual]

Reimplemented in QDataTable.  

int QTable::numSelections () const

void QTable::paintCell ( QPainter * p, int row, int col, const QRect & cr, bool selected, const QColorGroup & cg ) [virtual]

If selected is TRUE the cell is highlighted.

cg is the colorgroup which should be used to draw the cell content.

If you want to draw custom cell content, for example right-aligned text, you must either reimplement paintCell(), or subclass QTableItem and reimplement QTableItem::paint() to do the custom drawing.

If you're using a QTableItem subclass, for example, to store a data structure, then reimplementing QTableItem::paint() may be the best approach. For data you want to draw immediately, e.g. data retrieved from a database, it is probably best to reimplement paintCell(). Note that if you reimplement paintCell(), i.e. don't use QTableItems, you must reimplement other functions: see the notes on large tables.

Note that the painter is not clipped by default in order to get maximum efficiency. If you want clipping, use code like this:

    p->setClipRect( cellRect(row, col), QPainter::CoordPainter );


    //... your drawing code


    p->setClipping( FALSE );

void QTable::paintCell ( QPainter * p, int row, int col, const QRect & cr, bool selected ) [virtual]

Use the other paintCell() function. This function is only included for backwards compatibilty.  

void QTable::paintEmptyArea ( QPainter * p, int cx, int cy, int cw, int ch ) [virtual protected]

paintEmptyArea() is invoked by drawContents() to erase or fill unused areas.  

void QTable::paintFocus ( QPainter * p, const QRect & cr ) [virtual]

The painter p is already translated to the cell's origin, while cr specifies the cell's geometry in content coordinates.  

QPixmap QTable::pixmap ( int row, int col ) const [virtual]

See also setPixmap().

Example: chart/setdataform.cpp.  

void QTable::pressed ( int row, int col, int button, const QPoint & mousePos ) [signal]

See also Qt::ButtonState.  

void QTable::removeColumn ( int col ) [virtual slot]

See also removeColumns(), hideColumn(), insertColumns(), and removeRow().  

void QTable::removeColumns ( const QMemArray<int> & cols ) [virtual slot]

The array passed in must only contain valid columns (in the range from 0 to numCols() - 1) with no duplicates, and must be sorted in ascending order. Also clears the selection(s).

See also removeColumn(), insertColumns(), and removeRows().  

void QTable::removeRow ( int row ) [virtual slot]

See also hideRow(), insertRows(), removeColumn(), and removeRows().  

void QTable::removeRows ( const QMemArray<int> & rows ) [virtual slot]

The array passed in must only contain valid rows (in the range from 0 to numRows() - 1) with no duplicates, and must be sorted in ascending order. Also clears the selection(s).

See also removeRow(), insertRows(), and removeColumns().  

void QTable::removeSelection ( const QTableSelection & s ) [virtual]

See also addSelection() and numSelections.  

void QTable::removeSelection ( int num ) [virtual]

Removes selection number num from the table.

See also numSelections, addSelection(), and clearSelection().  

void QTable::repaintSelections ()

void QTable::resizeData ( int len ) [virtual protected]

If you don't use QTableItems you should reimplement this as an empty method to avoid wasting memory. See the notes on large tables for further details.  

int QTable::rowAt ( int y ) const [virtual]

See also rowPos() and columnAt().  

int QTable::rowHeight ( int row ) const [virtual]

See also setRowHeight() and columnWidth().

Example: table/small-table-demo/main.cpp.  

void QTable::rowHeightChanged ( int row ) [virtual protected slot]

void QTable::rowIndexChanged ( int section, int fromIndex, int toIndex ) [virtual protected slot]

If you want to change the order programmatically, call swapRows() or swapColumns();

See also QHeader::indexChange() and columnIndexChanged().  

bool QTable::rowMovingEnabled () const

int QTable::rowPos ( int row ) const [virtual]

See also rowAt() and columnPos().  

void QTable::selectCells ( int start_row, int start_col, int end_row, int end_col )

See also QTableSelection.  

void QTable::selectColumn ( int col )

See also QTableSelection.  

void QTable::selectRow ( int row )

See also QTableSelection.  

QTableSelection QTable::selection ( int num ) const

void QTable::selectionChanged () [signal]

See also QTableSelection.  

SelectionMode QTable::selectionMode () const

void QTable::setCellContentFromEditor ( int row, int col ) [virtual protected]

If there already exists a QTableItem for the cell, it calls QTableItem::setContentFromEditor() on this QTableItem.

If, for example, you want to create different QTableItems depending on the contents of the editor, you might reimplement this function.

If you want to work without QTableItems, you will need to reimplement this function to save the data the user entered into your data structure. (See the notes on large tables.)

See also QTableItem::setContentFromEditor() and createEditor().  

void QTable::setCellWidget ( int row, int col, QWidget * e ) [virtual]

By default widgets are inserted into a vector with numRows() * numCols() elements. In very large tables you will probably want to store the widgets in a data structure that consumes less memory (see the notes on large tables). To support the use of your own data structure this function calls insertWidget() to add the widget to the internal data structure. To use your own data structure reimplement insertWidget(), cellWidget() and clearCellWidget().

Cell widgets are created dynamically with the new operator. The cell widgets are destroyed automatically once the table is destroyed; the table takes ownership of the widget when using setCellWidget.

Example: chart/setdataform.cpp.  

void QTable::setColumnLabels ( const QStringList & labels ) [slot]

void QTable::setColumnMovingEnabled ( bool b ) [virtual slot]

void QTable::setColumnReadOnly ( int col, bool ro ) [virtual slot]

Whether a cell in this column is editable or read-only depends on the cell's EditType, and this setting: see QTableItem::EditType.

See also isColumnReadOnly(), setRowReadOnly(), and readOnly.

Example: chart/setdataform.cpp.  

void QTable::setColumnStretchable ( int col, bool stretch ) [virtual slot]

If the table widget's width decreases or increases stretchable columns will grow narrower or wider to fit the space available as completely as possible. The user cannot manually resize stretchable columns.

See also isColumnStretchable(), setRowStretchable(), and adjustColumn().  

void QTable::setColumnWidth ( int col, int w ) [virtual slot]

See also columnWidth() and setRowHeight().

Example: chart/setdataform.cpp.

Reimplemented in QDataTable.  

void QTable::setCurrentCell ( int row, int col ) [virtual slot]

See also currentRow() and currentColumn().  

void QTable::setDragEnabled ( bool b ) [virtual slot]

void QTable::setEditMode ( EditMode mode, int row, int col ) [protected]

See also EditMode.  

void QTable::setFocusStyle ( FocusStyle fs ) [virtual]

void QTable::setItem ( int row, int col, QTableItem * item ) [virtual]

If you don't use QTableItems you may need to reimplement this function: see the notes on large tables.

See also item() and takeItem().

Examples:  

void QTable::setLeftMargin ( int m ) [virtual slot]

The verticalHeader(), which displays row labels, occupies this margin.

In an Arabic or Hebrew localization, the verticalHeader() will appear on the right side of the table, and this call will set the right margin.

See also leftMargin(), setTopMargin(), and verticalHeader().

Example: regexptester/regexptester.cpp.  

void QTable::setNumCols ( int r ) [virtual slot]

void QTable::setNumRows ( int r ) [virtual slot]

void QTable::setPixmap ( int row, int col, const QPixmap & pix ) [virtual]

If the cell does not contain a table item a QTableItem is created with an EditType of OnTyping, otherwise the existing table item's pixmap (if any) is replaced with pix.

Note that QComboTableItems and QCheckTableItems don't show pixmaps.

See also pixmap(), setText(), setItem(), and QTableItem::setPixmap().

Examples:  

void QTable::setReadOnly ( bool b ) [virtual slot]

void QTable::setRowHeight ( int row, int h ) [virtual slot]

See also rowHeight() and setColumnWidth().  

void QTable::setRowLabels ( const QStringList & labels ) [slot]

void QTable::setRowMovingEnabled ( bool b ) [virtual slot]

void QTable::setRowReadOnly ( int row, bool ro ) [virtual slot]

Whether a cell in this row is editable or read-only depends on the cell's EditType, and this setting: see QTableItem::EditType.

See also isRowReadOnly(), setColumnReadOnly(), and readOnly.  

void QTable::setRowStretchable ( int row, bool stretch ) [virtual slot]

If the table widget's height decreases or increases stretchable rows will grow shorter or taller to fit the space available as completely as possible. The user cannot manually resize stretchable rows.

See also isRowStretchable() and setColumnStretchable().  

void QTable::setSelectionMode ( SelectionMode mode ) [virtual]

void QTable::setShowGrid ( bool b ) [virtual slot]

void QTable::setSorting ( bool b ) [virtual slot]

void QTable::setText ( int row, int col, const QString & text ) [virtual]

If the cell does not contain a table item a QTableItem is created with an EditType of OnTyping, otherwise the existing table item's text (if any) is replaced with text.

See also text(), setPixmap(), setItem(), and QTableItem::setText().

Examples:  

void QTable::setTopMargin ( int m ) [virtual slot]

The horizontalHeader(), which displays column labels, occupies this margin.

See also topMargin() and setLeftMargin().

Example: regexptester/regexptester.cpp.  

void QTable::showColumn ( int col ) [virtual slot]

See also hideColumn() and showRow().  

bool QTable::showGrid () const

void QTable::showRow ( int row ) [virtual slot]

See also hideRow() and showColumn().  

void QTable::sortColumn ( int col, bool ascending = TRUE, bool wholeRows = FALSE ) [virtual]

If wholeRows is TRUE, entire rows are sorted using swapRows(); otherwise only cells in the column are sorted using swapCells().

Note that if you are not using QTableItems you will need to reimplement swapRows() and swapCells(). (See the notes on large tables.)

See also swapRows().

Example: table/statistics/statistics.cpp.

Reimplemented in QDataTable.  

bool QTable::sorting () const

void QTable::startDrag () [virtual protected]

Usually you don't need to call or reimplement this function yourself.

See also dragObject().  

void QTable::swapCells ( int row1, int col1, int row2, int col2 ) [virtual slot]

This function is also called when the table is sorted.

If you don't use QTableItems and want your users to be able to swap cells, you will need to reimplement this function. (See the notes on large tables.)

See also swapColumns() and swapRows().  

void QTable::swapColumns ( int col1, int col2, bool swapHeader = FALSE ) [virtual slot]

This function is used to swap the positions of two columns. It is called when the user changes the order of columns (see setColumnMovingEnabled(), and when columns are sorted.

If you don't use QTableItems and want your users to be able to swap columns you will need to reimplement this function. (See the notes on large tables.)

If swapHeader is TRUE, the columns' header contents is also swapped.

See also swapCells().  

void QTable::swapRows ( int row1, int row2, bool swapHeader = FALSE ) [virtual slot]

This function is used to swap the positions of two rows. It is called when the user changes the order of rows (see setRowMovingEnabled()), and when rows are sorted.

If you don't use QTableItems and want your users to be able to swap rows, e.g. for sorting, you will need to reimplement this function. (See the notes on large tables.)

If swapHeader is TRUE, the rows' header contents is also swapped.

This function will not update the QTable, you will have to do this manually, e.g. by calling updateContents().

See also swapColumns() and swapCells().  

void QTable::takeItem ( QTableItem * i ) [virtual]

Use this function if you want to move an item from one cell in a table to another, or to move an item from one table to another, reinserting the item with setItem().

If you want to exchange two cells use swapCells().  

QString QTable::text ( int row, int col ) const [virtual]

See also setText() and setPixmap().

Example: chart/setdataform.cpp.

Reimplemented in QDataTable.  

void QTable::updateCell ( int row, int col )

void QTable::updateHeaderStates ()

void QTable::valueChanged ( int row, int col ) [signal]

Example: chart/setdataform.cpp.  

QHeader * QTable::verticalHeader () const

This header contains the row labels.

See also horizontalHeader(), setLeftMargin(), and QHeader.

Examples:  

Property Documentation

bool columnMovingEnabled

The default is FALSE. Columns are moved by dragging whilst holding down the Ctrl key.

Warning: If QTable is used to move header sections as a result of user interaction, the mapping between header indexes and section exposed by QHeader will not reflect the order of the headers in the table; i.e., QTable does not call QHeader::moveSection() to move sections but handles move operations internally.

See also rowMovingEnabled.

Set this property's value with setColumnMovingEnabled() and get this property's value with columnMovingEnabled().  

FocusStyle focusStyle

The default style is SpreadSheet.

See also QTable::FocusStyle.

Set this property's value with setFocusStyle() and get this property's value with focusStyle().  

int numCols

Set this property's value with setNumCols() and get this property's value with numCols().

See also numRows.  

int numRows

Set this property's value with setNumRows() and get this property's value with numRows().

See also numCols.  

int numSelections

Get this property's value with numSelections().

See also currentSelection().  

bool readOnly

Whether a cell in the table is editable or read-only depends on the cell's EditType, and this setting: see QTableItem::EditType.

See also QWidget::enabled, setColumnReadOnly(), and setRowReadOnly().

Set this property's value with setReadOnly() and get this property's value with isReadOnly().  

bool rowMovingEnabled

The default is FALSE. Rows are moved by dragging whilst holding down the Ctrl key.

Warning: If QTable is used to move header sections as a result of user interaction, the mapping between header indexes and section exposed by QHeader will not reflect the order of the headers in the table; i.e., QTable does not call QHeader::moveSection() to move sections but handles move operations internally.

See also columnMovingEnabled.

Set this property's value with setRowMovingEnabled() and get this property's value with rowMovingEnabled().  

SelectionMode selectionMode

The default mode is Multi which allows the user to select multiple ranges of cells.

See also SelectionMode and selectionMode.

Set this property's value with setSelectionMode() and get this property's value with selectionMode().  

bool showGrid

The grid is shown by default.

Set this property's value with setShowGrid() and get this property's value with showGrid().  

bool sorting

Set this property's value with setSorting() and get this property's value with sorting().

See also sortColumn().

SEE ALSO

COPYRIGHT

AUTHOR

BUGS