Q3Table Class Reference
^{[Qt3Support module]}

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.

Member Type Documentation

enum Q3Table::EditMode

enum Q3Table::FocusStyle

Specifies how the current cell (focus cell) is drawn.

enum Q3Table::SelectionMode

Property Documentation

columnMovingEnabled : bool

This property holds whether columns can be moved by the user.

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

Access functions:

• bool columnMovingEnabled () const
• virtual void setColumnMovingEnabled ( bool b )

See also rowMovingEnabled.

focusStyle : FocusStyle

This property holds how the current (focus) cell is drawn.

The default style is SpreadSheet.

Access functions:

• FocusStyle focusStyle () const
• virtual void setFocusStyle ( FocusStyle fs )

See also Q3Table::FocusStyle.

numCols : int

This property holds the number of columns in the table.

Access functions:

• virtual int numCols () const
• virtual void setNumCols ( int r )

See also numRows.

numRows : int

This property holds the number of rows in the table.

Access functions:

• virtual int numRows () const
• virtual void setNumRows ( int r )

See also numCols.

numSelections : const int

This property holds the number of selections.

Access functions:

• int numSelections () const

See also currentSelection().

readOnly : bool

This property holds whether the table is read-only.

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

Access functions:

• bool isReadOnly () const
• virtual void setReadOnly ( bool b )

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

rowMovingEnabled : bool

This property holds whether rows can be moved by the user.

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

Access functions:

• bool rowMovingEnabled () const
• virtual void setRowMovingEnabled ( bool b )

See also columnMovingEnabled.

selectionMode : SelectionMode

This property holds the current selection mode.

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

Access functions:

• SelectionMode selectionMode () const
• virtual void setSelectionMode ( SelectionMode mode )

showGrid : bool

This property holds whether the table's grid is displayed.

The grid is shown by default.

Access functions:

• bool showGrid () const
• virtual void setShowGrid ( bool b )

sorting : bool

This property holds whether a click on the header of a column sorts that column.

Access functions:

• bool sorting () const
• virtual void setSorting ( bool b )

See also sortColumn().

Member Function Documentation

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

Creates an empty table object called name as a child of parent.

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

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

Constructs an empty table called name with numRows rows and numCols columns. The table is a child of parent.

If you're using Q3TableItems to populate the table's cells, you can create Q3TableItem, Q3ComboTableItem and Q3CheckTableItem items and insert them into the table using setItem(). (See the notes on large tables for an alternative to using Q3TableItems.)

Q3Table::~Q3Table ()

Releases all the resources used by the Q3Table object, including all Q3TableItems and their widgets.

void Q3Table::activateNextCell ()   [virtual protected]

This function is called to activate the next cell if in-place editing was finished by pressing the Enter key.

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 Q3Table::addSelection ( const Q3TableSelection & s )   [virtual]

Adds a selection described by s to the table and returns its number or -1 if the selection is invalid.

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

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

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

Resizes column col so that the column width is wide enough to display the widest item the column contains.

See also adjustRow().

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

Resizes row row so that the row height is tall enough to display the tallest item the row contains.

See also adjustColumn().

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

This function is called to start in-place editing of the cell at row, col. 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 replace 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.

See also endEdit().

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

Returns the bounding rectangle of the cell at row, col in content coordinates.

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

Returns the geometry of cell row, col in the cell's coordinate system. This is a convenience function useful in paintCell(). It is equivalent to QRect(QPoint(0,0), cellGeometry( row, col).size());

See also cellGeometry().

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

Returns the widget that has been set for the cell at row, col, or 0 if no widget has been set.

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

See also clearCellWidget() and setCellWidget().

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

Removes the Q3TableItem at row, col.

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

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

Removes the widget (if there is one) set for the cell at row, col.

If you don't use Q3TableItems 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 Q3Table::clearSelection ( bool repaint = true )   [slot]

Clears all selections and repaints the appropriate regions if repaint is true.

See also removeSelection().

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

This signal is emitted when mouse button button is clicked. The cell where the event took place is at row, col, and the mouse's position is in mousePos.

See also Qt::MouseButton.

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

Returns the number of the column at position x. x must be given in content coordinates.

See also columnPos() and rowAt().

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

This function is called when the column col has been clicked. The default implementation sorts this column if sorting() is true.

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

This function is called when column order is to be changed, i.e. when the user moved the column header section from fromIndex to toIndex.

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

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

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

Returns the x-coordinate of the column col in content coordinates.

See also columnAt() and rowPos().

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

Returns the width of column col.

See also setColumnWidth() and rowHeight().

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

This function should be called whenever the column width of col has been changed. It updates the geometry of any affected columns and repaints the table to reflect the changes it has made.

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

This event handler is called whenever a Q3Table object receives a QDragEnterEvent e, i.e. when the user pressed the mouse button to drag something.

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

Reimplemented from Q3ScrollView.

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

This event handler is called when a drag activity leaves this Q3Table object with event e.

Reimplemented from Q3ScrollView.

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

This event handler is called whenever a Q3Table object receives a QDragMoveEvent e, i.e. when the user actually drags the mouse.

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

Reimplemented from Q3ScrollView.

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

This event handler is called when the user ends a drag and drop by dropping something onto this Q3Table and thus triggers the drop event, e.

Reimplemented from Q3ScrollView.

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

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 row, col. pos 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.

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

This function returns the widget which should be used as an editor for the contents of the cell at row, col.

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 Q3TableItem and the table item's Q3TableItem::isReplaceable() is false then the cell is asked to create an appropriate editor (using Q3TableItem::createEditor()). Otherwise a QLineEdit is used as the editor.

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

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

    Q3TableItem *i = item(row, col);
    if (initFromCell || (i && !i->isReplaceable()))
        // If we had a Q3TableItem ask the base class to create the editor
        return Q3Table::createEditor(row, col, initFromCell);
    else
        return ...(create your own editor)

Ownership of the editor widget is transferred to the caller.

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 Q3TableItem::createEditor().

int Q3Table::currEditCol () const   [protected]

Returns the current edited column

int Q3Table::currEditRow () const   [protected]

Returns the current edited row

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

This signal is emitted when the current cell has changed to row, col.

int Q3Table::currentColumn () const

Returns the current column.

See also currentRow().

int Q3Table::currentRow () const

Returns the current row.

See also currentColumn().

int Q3Table::currentSelection () const   [virtual]

Returns the number of the current selection or -1 if there is no current selection.

See also numSelections().

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

This signal is emitted when mouse button button is double-clicked. The cell where the event took place is at row, col, and the mouse's position is in mousePos.

See also Qt::MouseButton.

bool Q3Table::dragEnabled () const

If this function returns true, the table supports dragging.

See also setDragEnabled().

Q3DragObject * Q3Table::dragObject ()   [virtual protected]

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.

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

See also dropped().

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

Draws the table contents on the painter p. This function is optimized so that it only draws the cells inside the cw pixels wide and ch pixels high clipping rectangle at position cx, cy.

Additionally, drawContents() highlights the current cell.

Reimplemented from Q3ScrollView.

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

This signal is emitted when a drop event occurred on the table.

e contains information about the drop.

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

Starts editing the cell at row, col.

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 Q3Table::editMode () const   [protected]

Returns the current edit mode

See also setEditMode() and Q3Table::EditMode.

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

This function is called when in-place editing of the cell at row, col is requested to stop.

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 Q3TableItem 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 Q3TableItem 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 Q3Table::ensureCellVisible ( int row, int col )

Scrolls the table until the cell at row, col becomes visible.

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

Hides column col.

See also showColumn() and hideRow().

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

Hides row row.

See also showRow() and hideColumn().

Q3Header * Q3Table::horizontalHeader () const

Returns the table's top Q3Header.

This header contains the column labels.

To modify a column label use Q3Header::setLabel().

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

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

Returns a single integer which identifies a particular row and col by mapping the 2D table to a 1D array.

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

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

Inserts count empty columns at column col. Also clears the selection(s).

See also insertRows() and removeColumn().

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

Inserts count empty rows at row row. Also clears the selection(s).

See also insertColumns() and removeRow().

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

Inserts widget w at row, col into the internal data structure. See the documentation of setCellWidget() for further details.

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

bool Q3Table::isColumnHidden ( int col ) const

Returns true if column col is hidden; otherwise returns false.

See also hideColumn() and isRowHidden().

bool Q3Table::isColumnReadOnly ( int col ) const

Returns true if column col is read-only; otherwise returns false.

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

See also setColumnReadOnly() and isRowReadOnly().

bool Q3Table::isColumnSelected ( int col, bool full = false ) const

Returns true if column col is selected; otherwise returns false.

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 Q3Table::isColumnStretchable ( int col ) const

Returns true if column col is stretchable; otherwise returns false.

See also setColumnStretchable() and isRowStretchable().

bool Q3Table::isEditing () const   [protected]

Returns true if the EditMode is Editing or Replacing; otherwise (i.e. the EditMode is NotEditing) returns false.

See also Q3Table::EditMode.

bool Q3Table::isRowHidden ( int row ) const

Returns true if row row is hidden; otherwise returns false.

See also hideRow() and isColumnHidden().

bool Q3Table::isRowReadOnly ( int row ) const

Returns true if row row is read-only; otherwise returns false.

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

See also setRowReadOnly() and isColumnReadOnly().

bool Q3Table::isRowSelected ( int row, bool full = false ) const

Returns true if row row is selected; otherwise returns false.

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 Q3Table::isRowStretchable ( int row ) const

Returns true if row row is stretchable; otherwise returns false.

See also setRowStretchable() and isColumnStretchable().

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

Returns true if the cell at row, col is selected; otherwise returns false.

See also isRowSelected() and isColumnSelected().

Q3TableItem * Q3Table::item ( int row, int col ) const   [virtual]

Returns the Q3TableItem representing the contents of the cell at row, col.

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 Q3TableItems you may need to reimplement this function: see the notes on large tables.

See also setItem().

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

Paints the cell at row, col on the painter p. The painter has already been translated to the cell's origin. cr describes the cell coordinates in the content coordinate system.

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 Q3TableItem and reimplement Q3TableItem::paint() to do the custom drawing.

If you're using a Q3TableItem subclass, for example, to store a data structure, then reimplementing Q3TableItem::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 Q3TableItems, 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 Q3Table::paintCell ( QPainter * p, int row, int col, const QRect & cr, bool selected )   [virtual]

This is an overloaded member function, provided for convenience.

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

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

This function fills the cw pixels wide and ch pixels high rectangle starting at position cx, cy with the background color using the painter p.

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

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

Draws the focus rectangle of the current cell (see currentRow(), currentColumn()).

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

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

Returns the pixmap set for the cell at row, col, or a null-pixmap if the cell contains no pixmap.

See also setPixmap().

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

This signal is emitted when mouse button button is pressed. The cell where the event took place is at row, col, and the mouse's position is in mousePos.

See also Qt::MouseButton.

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

Removes column col, and deletes all its cells including any table items and widgets the cells may contain. Also clears the selection(s).

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

void Q3Table::removeColumns ( const Q3MemArray<int> & cols )   [virtual slot]

Removes the columns listed in the array cols, and deletes all their cells including any table items and widgets the cells may contain.

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 Q3Table::removeRow ( int row )   [virtual slot]

Removes row row, and deletes all its cells including any table items and widgets the cells may contain. Also clears the selection(s).

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

void Q3Table::removeRows ( const Q3MemArray<int> & rows )   [virtual slot]

Removes the rows listed in the array rows, and deletes all their cells including any table items and widgets the cells may contain.

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 Q3Table::removeSelection ( const Q3TableSelection & s )   [virtual]

If the table has a selection, s, this selection is removed from the table.

See also addSelection() and numSelections().

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

This is an overloaded member function, provided for convenience.

Removes selection number num from the table.

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

void Q3Table::repaintSelections ()

Repaints all selections

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

This is called when Q3Table's internal array needs to be resized to len elements.

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

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

Returns the number of the row at position y. y must be given in content coordinates.

See also rowPos() and columnAt().

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

Returns the height of row row.

See also setRowHeight() and columnWidth().

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

This function should be called whenever the row height of row has been changed. It updates the geometry of any affected rows and repaints the table to reflect the changes it has made.

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

This function is called when the order of the rows is to be changed, i.e. the user moved the row header section section from fromIndex to toIndex.

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

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

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

Returns the y-coordinate of the row row in content coordinates.

See also rowAt() and columnPos().

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

Selects the range starting at start_row and start_col and ending at end_row and end_col.

See also Q3TableSelection.

void Q3Table::selectColumn ( int col )   [virtual]

Selects the column col.

See also Q3TableSelection.

void Q3Table::selectRow ( int row )   [virtual]

Selects the row row.

See also Q3TableSelection.

Q3TableSelection Q3Table::selection ( int num ) const

Returns selection number num, or an inactive Q3TableSelection if num is out of range (see Q3TableSelection::isActive()).

void Q3Table::selectionChanged ()   [signal]

This signal is emitted whenever a selection changes.

See also Q3TableSelection.

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

This function is called to replace the contents of the cell at row, col with the contents of the cell's editor.

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

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

If you want to work without Q3TableItems, 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 Q3TableItem::setContentFromEditor() and createEditor().

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

Sets the widget e to the cell at row, col and takes care of placing and resizing the widget when the cell geometry changes.

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.

See also cellWidget().

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

Sets the section labels of the horizontalHeader() to labels

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

If ro is true, column col is set to be read-only; otherwise the column is set to be editable.

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

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

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

If stretch is true, column col is set to be stretchable; otherwise column col is set to be unstretchable.

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 Q3Table::setColumnWidth ( int col, int w )   [virtual slot]

Resizes column col to be w pixels wide.

See also columnWidth() and setRowHeight().

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

Moves the focus to the cell at row, col.

See also currentRow() and currentColumn().

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

If b is true, the table starts a drag (see dragObject()) when the user presses and moves the mouse on a selected cell.

See also dragEnabled().

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

Sets the current edit mode to mode, the current edit row to row and the current edit column to col.

See also editMode() and EditMode.

void Q3Table::setItem ( int row, int col, Q3TableItem * item )   [virtual]

Inserts the table item item into the table at row row, column col, and repaints the cell. If a table item already exists in this cell it is deleted and replaced with item. The table takes ownership of the table item.

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

See also item() and takeItem().

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

Sets the left margin to be m pixels wide.

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().

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

Sets the pixmap in the cell at row, col to pix.

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

Note that Q3ComboTableItems and Q3CheckTableItems don't show pixmaps.

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

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

Resizes row row to be h pixels high.

See also rowHeight() and setColumnWidth().

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

Sets the section labels of the verticalHeader() to labels

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

If ro is true, row row is set to be read-only; otherwise the row is set to be editable.

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

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

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

If stretch is true, row row is set to be stretchable; otherwise row row is set to be unstretchable.

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 Q3Table::setText ( int row, int col, const QString & text )   [virtual]

Sets the text in the cell at row, col to text.

If the cell does not contain a table item a Q3TableItem 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 Q3TableItem::setText().

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

Sets the top margin to be m pixels high.

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

See also topMargin() and setLeftMargin().

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

Shows column col.

See also hideColumn() and showRow().

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

Shows row row.

See also hideRow() and showColumn().

void Q3Table::sortColumn ( int col, bool ascending = true, bool wholeRows = false )   [virtual]

Sorts column col. If ascending is true the sort is in ascending order, otherwise the sort is in descending order.

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 Q3TableItems you will need to reimplement swapRows() and swapCells(). (See the notes on large tables.)

See also swapRows().

void Q3Table::startDrag ()   [virtual protected]

Starts a drag.

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

See also dragObject().

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

Swaps the contents of the cell at row1, col1 with the contents of the cell at row2, col2.

This function is also called when the table is sorted.

If you don't use Q3TableItems 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 Q3Table::swapColumns ( int col1, int col2, bool swapHeader = false )   [virtual slot]

Swaps the data in col1 with col2.

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 Q3TableItems 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 Q3Table::swapRows ( int row1, int row2, bool swapHeader = false )   [virtual slot]

Swaps the data in row1 and row2.

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 Q3TableItems 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 Q3Table, you will have to do this manually, e.g. by calling updateContents().

See also swapColumns() and swapCells().

void Q3Table::takeItem ( Q3TableItem * i )   [virtual]

Takes the table item i out of the table. This function does not 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.

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 Q3Table::text ( int row, int col ) const   [virtual]

Returns the text in the cell at row, col, or an empty string if the relevant item does not exist or has no text.

See also setText() and setPixmap().

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

Repaints the cell at row, col.

void Q3Table::updateHeaderStates ()

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.

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

This signal is emitted when the user changed the value in the cell at row, col.

Q3Header * Q3Table::verticalHeader () const

Returns the table's vertical Q3Header.

This header contains the row labels.

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