TQTable is easy to use, although it does have a large API because of the comprehensive functionality that it provides. TQTable includes functions for manipulating headers, rows and columns, cells and selections. TQTable also provides in-place editing and drag and drop, as well as a useful set of signals. TQTable efficiently supports very large tables, for example, tables one million by one million cells are perfectly possible. TQTable is economical with memory, using none for unused cells.
The first line constructs the table specifying its size in rows and columns. We then insert a pixmap and some text into the \fIsame\fR cell, with the pixmap appearing to the left of the text. TQTable cells can be populated with TQTableItems, TQComboTableItems or by TQCheckTableItems. 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 TQTable begin at 0.)
TQTable supports a header column, e.g. to display row numbers, and a header row, e.g to display column titles. To set row or column labels use TQHeader::setLabel() on the pointers returned by verticalHeader() and horizontalHeader() respectively. The vertical header is displayed within the table's left margin whose width is set with setLeftMargin(). The horizontal header is displayed within the table's top margin whose height is set with setTopMargin(). The table's grid can be switched off with setShowGrid(). If you want to hide a horizontal header call hide(), and call setTopMargin( 0 ) so that the area the header would have occupied is reduced to zero size.
Header labels are indexed via their section numbers. Note that the default behavior of TQHeader regarding section numbers is overriden for TQTable. See the explanation below in the Rows and Columns section in the discussion of moving columns and rows.
Row and column sizes are set with setRowHeight() and setColumnWidth(). If you want a row high enough to show the tallest item in its entirety, use adjustRow(). Similarly, to make a column wide enough to show the widest item use adjustColumn(). If you want the row height and column width to adjust automatically as the height and width of the table changes use setRowStretchable() and setColumnStretchable().
.PP
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 TQHeader section numbers is overridden by TQTable. Currently in TQTable, 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 TQHeader. The TQTable TQHeader 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 TQTableItem::EditType.)
There are two approaches to populating the table's cells. The first and simplest approach is to use TQTableItems or TQTableItem subclasses. The second approach doesn't use TQTableItems 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 TQTableItem 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 TQLineEdit. A pixmap may be put in a cell with setPixmap(), which also creates a table item if required. A cell may contain \fIboth\fR a pixmap and text; the pixmap is displayed to the left of the text. Another approach is to construct a TQTableItem or TQTableItem subclass, set its properties, then insert it into a cell with setItem().
If you want cells which contain comboboxes use the TQComboTableItem class. Similarly if you require cells containing checkboxes use the TQCheckTableItem class. These table items look and behave just like the combobox or checkbox widgets but consume far less memory.
TQTable takes ownership of its TQTableItems 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 TQTableItems, and the values in TQComboTableItems and TQCheckTableItems works automatically. Cells may be editable or read-only, see TQTableItem::EditType. If you want fine control over editing see beginEdit() and endEdit().
The contents of a cell can be retrieved as a TQTableItem 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 TQTableItem might be a simpler approach. The cell's widget (if there is one) can be removed with clearCellWidget().
For large, sparse, tables using TQTableItems or other widgets is inefficient. The solution is to \fIdraw\fR 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 TQTable 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 TQTableItems and TQWidgets, 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.)
TQTable's support single selection, multi-selection (multiple cells) or no selection. The selection mode is set with setSelectionMode(). Use isSelected() to determine if a particular cell is selected, and isRowSelected() and isColumnSelected() to see if a row or column is selected.
TQTable'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 TQTableSelection objects.
Alternatively, use addSelection() to add new selections using TQTableSelection objects. The advantage of using TQTableSelection objects is that you can call TQTableSelection::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().
.SH "Signals"
When the user clicks a cell the currentChanged() signal is emitted. You can also connect to the lower level clicked(), doubleClicked() and pressed() signals. If the user changes the selection the selectionChanged() signal is emitted; similarly if the user changes a cell's value the valueChanged() signal is emitted. If the user right-clicks (or presses the appropriate platform-specific key sequence) the contextMenuRequested() signal is emitted. If the user drops a drag and drop object the dropped() signal is emitted with the drop event.
\fCTQTable::FollowStyle\fR - 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
\fCTQTable::SpreadSheet\fR - 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.
If you're using TQTableItems to populate the table's cells, you can create TQTableItem, TQComboTableItem and TQCheckTableItem items and insert them into the table using setItem(). (See the notes on large tables for an alternative to using TQTableItems.)
This function is called to activate the next cell if in-place editing was finished by pressing the Enter key.
.PP
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.
Remember to call TQTableSelection::init() and TQTableSelection::expandTo() to make the selection valid (see also TQTableSelection::isActive(), or use the TQTableSelection(int,int,int,int) constructor).
This function is called to start in-place editing of the cell at \fIrow\fR, \fIcol\fR. Editing is achieved by creating an editor (createEditor() is called) and setting the cell's editor with setCellWidget() to the newly created editor. (After editing is complete endEdit() will be called to replace the cell's content with the editor's content.) If \fIreplace\fR is TRUE the editor will start empty; otherwise it will be initialized with the cell's content (if any), i.e. the user will be modifying the original cell content.
Returns the geometry of cell \fIrow\fR, \fIcol\fR in the cell's coordinate system. This is a convenience function useful in paintCell(). It is equivalent to TQRect( TQPoint(0,0), cellGeometry( row, col).size() );
This function deletes the widget at \fIrow\fR, \fIcol\fR. Note that the widget is not deleted immediately; instead TQObject::deleteLater() is called on the widget to avoid problems with timing issues.
This signal is emitted when mouse button \fIbutton\fR is clicked. The cell where the event took place is at \fIrow\fR, \fIcol\fR, and the mouse's position is in \fImousePos\fR.
This function is called when column order is to be changed, i.e. when the user moved the column header \fIsection\fR from \fIfromIndex\fR to \fItoIndex\fR.
.PP
If you want to change the column order programmatically, call swapRows() or swapColumns();
This function should be called whenever the column width of \fIcol\fR has been changed. It updates the geometry of any affected columns and repaints the table to reflect the changes it has made.
.SH "void TQTable::contentsDragEnterEvent ( TQDragEnterEvent * e )\fC [virtual protected]\fR"
This event handler is called whenever a TQTable object receives a TQDragEnterEvent \fIe\fR, i.e. when the user pressed the mouse button to drag something.
.SH "void TQTable::contentsDropEvent ( TQDropEvent * e )\fC [virtual protected]\fR"
This event handler is called when the user ends a drag and drop by dropping something onto \fIthis\fR TQTable and thus triggers the drop event, \fIe\fR.
This signal is emitted when the user invokes a context menu with the right mouse button (or with a system-specific keypress). The cell where the event took place is at \fIrow\fR, \fIcol\fR. \fIpos\fR is the position where the context menu will appear in the global coordinate system. This signal is always emitted, even if the contents of the cell are disabled.
This function returns the widget which should be used as an editor for the contents of the cell at \fIrow\fR, \fIcol\fR.
.PP
If \fIinitFromCell\fR 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 \fIinitFromCell\fR 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 \fIinitFromCell\fR is TRUE or the cell has a TQTableItem and the table item's TQTableItem::isReplaceable() is FALSE then the cell is asked to create an appropriate editor (using TQTableItem::createEditor()). Otherwise a TQLineEdit is used as the editor.
If you are not using TQTableItems and you don't want to use a TQLineEdit as the default editor, subclass TQTable and reimplement this function with code like this:
Ownership of the editor widget is transferred to the caller.
.PP
If you reimplement this function return 0 for read-only cells. You will need to reimplement setCellContentFromEditor() to retrieve the data the user entered.
This signal is emitted when mouse button \fIbutton\fR is double-clicked. The cell where the event took place is at \fIrow\fR, \fIcol\fR, and the mouse's position is in \fImousePos\fR.
If the user presses the mouse on a selected cell, starts moving (i.e. dragging), and dragEnabled() is TRUE, this function is called to obtain a drag object. A drag using this object begins immediately unless dragObject() returns 0.
Draws the table contents on the painter \fIp\fR. This function is optimized so that it only draws the cells inside the \fIcw\fR pixels wide and \fIch\fR pixels high clipping rectangle at position \fIcx\fR, \fIcy\fR.
.PP
Additionally, drawContents() highlights the current cell.
If \fIreplace\fR 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.
If \fIaccept\fR is TRUE the content of the editor must be transferred to the relevant cell. If \fIreplace\fR is TRUE the current content of this cell should be replaced by the content of the editor (this means removing the current TQTableItem 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 TQTableItem of this cell.
Returns TRUE if column \fIcol\fR is selected; otherwise returns FALSE.
.PP
If \fIfull\fR is FALSE (the default), 'column is selected' means that at least one cell in the column is selected. If \fIfull\fR is TRUE, then 'column is selected' means every cell in the column is selected.
Returns TRUE if row \fIrow\fR is selected; otherwise returns FALSE.
.PP
If \fIfull\fR is FALSE (the default), 'row is selected' means that at least one cell in the row is selected. If \fIfull\fR is TRUE, then 'row is selected' means every cell in the row is selected.
Paints the cell at \fIrow\fR, \fIcol\fR on the painter \fIp\fR. The painter has already been translated to the cell's origin. \fIcr\fR describes the cell coordinates in the content coordinate system.
.PP
If \fIselected\fR is TRUE the cell is highlighted.
.PP
\fIcg\fR 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 TQTableItem and reimplement TQTableItem::paint() to do the custom drawing.
If you're using a TQTableItem subclass, for example, to store a data structure, then reimplementing TQTableItem::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 TQTableItems, you must reimplement other functions: see the notes on large tables.
This function fills the \fIcw\fR pixels wide and \fIch\fR pixels high rectangle starting at position \fIcx\fR, \fIcy\fR with the background color using the painter \fIp\fR.
.PP
paintEmptyArea() is invoked by drawContents() to erase or fill unused areas.
This signal is emitted when mouse button \fIbutton\fR is pressed. The cell where the event took place is at \fIrow\fR, \fIcol\fR, and the mouse's position is in \fImousePos\fR.
Removes the columns listed in the array \fIcols\fR, and deletes all their cells including any table items and widgets the cells may contain.
.PP
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).
.PP
See also removeColumn(), insertColumns(), and removeRows().
Removes the rows listed in the array \fIrows\fR, and deletes all their cells including any table items and widgets the cells may contain.
.PP
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).
.PP
See also removeRow(), insertRows(), and removeColumns().
If you don't use TQTableItems you should reimplement this as an empty method to avoid wasting memory. See the notes on large tables for further details.
.SH "int TQTable::rowAt ( int y ) const\fC [virtual]\fR"
This function should be called whenever the row height of \fIrow\fR has been changed. It updates the geometry of any affected rows and repaints the table to reflect the changes it has made.
This function is called when the order of the rows is to be changed, i.e. the user moved the row header section \fIsection\fR from \fIfromIndex\fR to \fItoIndex\fR.
.PP
If you want to change the order programmatically, call swapRows() or swapColumns();
If you want to work without TQTableItems, you will need to reimplement this function to save the data the user entered into your data structure. (See the notes on large tables.)
Sets the widget \fIe\fR to the cell at \fIrow\fR, \fIcol\fR and takes care of placing and resizing the widget when the cell geometry changes.
.PP
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().
.PP
Cell widgets are created dynamically with the \fCnew\fR operator. The cell widgets are destroyed automatically once the table is destroyed; the table takes ownership of the widget when using setCellWidget.
If \fIstretch\fR is TRUE, column \fIcol\fR is set to be stretchable; otherwise column \fIcol\fR is set to be unstretchable.
.PP
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.
.PP
See also isColumnStretchable(), setRowStretchable(), and adjustColumn().
Inserts the table item \fIitem\fR into the table at row \fIrow\fR, column \fIcol\fR, and repaints the cell. If a table item already exists in this cell it is deleted and replaced with \fIitem\fR. The table takes ownership of the table item.
If the cell does not contain a table item a TQTableItem is created with an EditType of \fCOnTyping\fR, otherwise the existing table item's pixmap (if any) is replaced with \fIpix\fR.
If \fIstretch\fR is TRUE, row \fIrow\fR is set to be stretchable; otherwise row \fIrow\fR is set to be unstretchable.
.PP
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.
.PP
See also isRowStretchable() and setColumnStretchable().
If the cell does not contain a table item a TQTableItem is created with an EditType of \fCOnTyping\fR, otherwise the existing table item's text (if any) is replaced with \fItext\fR.
If you don't use TQTableItems and want your users to be able to swap cells, you will need to reimplement this function. (See the notes on large tables.)
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 TQTableItems and want your users to be able to swap columns you will need to reimplement this function. (See the notes on large tables.)
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 TQTableItems 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.)
Takes the table item \fIi\fR out of the table. This function does \fInot\fR delete the table item. You must either delete the table item yourself or put it into a table (using setItem()) which will then take ownership of it.
.PP
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().
.PP
If you want to exchange two cells use swapCells().
This functions updates all the header states to be in sync with the current selections. This should be called after programatically changing, adding or removing selections, so that the headers are updated.
\fBWarning:\fR If TQTable is used to move header sections as a result of user interaction, the mapping between header indexes and section exposed by TQHeader will not reflect the order of the headers in the table; i.e., TQTable does not call TQHeader::moveSection() to move sections but handles move operations internally.
\fBWarning:\fR If TQTable is used to move header sections as a result of user interaction, the mapping between header indexes and section exposed by TQHeader will not reflect the order of the headers in the table; i.e., TQTable does not call TQHeader::moveSection() to move sections but handles move operations internally.
