QTableItem Class Reference
[table module]

Detailed Description

For many applications QTableItems are ideal for presenting and editing the contents of QTable cells. In situations where you need to create very large tables you may prefer an alternative approach to using QTableItems: see the notes on large tables.

A QTableItem contains a cell's data, by default, a string and a pixmap. The table item also holds the cell's display size and how the data should be aligned. The table item specifies the cell's EditType and the editor used for in-place editing (by default a QLineEdit). If you want checkboxes use QCheckTableItem, and if you want comboboxes use QComboTableItem. The EditType (set in the constructor) determines whether the cell's contents may be edited; setReplaceable() sets whether the cell's contents may be replaced by another cell's contents.

If a pixmap is specified it is displayed to the left of any text. You can change the text or pixmap with setText() and setPixmap() respectively. For text you can use setWordWrap(). A table item's alignment is set in the constructor.

Reimplement createEditor() and setContentFromEditor() if you want to use your own widget instead of a QLineEdit for editing cell contents. Reimplement paint() if you want to display custom content. If you want a checkbox table item use QCheckTableItem, and if you want a combo table item use QComboTableItem.

When sorting table items the key() function is used; by default this returns the table item's text(). Reimplement key() to customize how your table items will sort.

Table items are inserted into a table using QTable::setItem(). If you insert an item into a cell that already contains a table item the original item will be deleted.

Example:

    for ( int row = 0; row < table->numRows(); row++ ) {
        for ( int col = 0; col < table->numCols(); col++ ) {
            table->setItem( row, col,
                new QTableItem( table, WhenCurrent, QString::number( row * col ) ) );
        }
    }
    

You can move a table item from one cell to another, in the same or a different table, using QTable::takeItem() and QTable::setItem() but see also QTable::swapCells().

Table items can be deleted with delete in the standard way; the table and cell will be updated accordingly.

See also QCheckTableItem, QComboTableItem and Advanced Widgets.

Member Type Documentation

QTableItem::EditType

This enum is used to define whether a cell is editable or read-only (in conjunction with other settings), and how the cell should be displayed.

• QTableItem::Always - The cell always looks editable.

Using this EditType ensures that the editor created with createEditor() (by default a QLineEdit) is always visible. This has implications for the alignment of the content: the default editor aligns everything (even numbers) to the left whilst numerical values in the cell are by default aligned to the right.

If a cell with the edit type Always looks misaligned you could reimplement createEditor() for these items.

• QTableItem::WhenCurrent - The cell looks editable only when it has keyboard focus (see QTable::setCurrentCell()).
• QTableItem::OnTyping - The cell looks editable only when the user types in it or double-clicks it. It resembles the WhenCurrent functionality but is, perhaps, nicer.

The OnTyping edit type is the default when QTableItem objects are created by the convenience functions QTable::setText() and QTable::setPixmap().

• QTableItem::Never - The cell is not editable.

The cell is actually editable only if QTable::isRowReadOnly() is FALSE for its row, QTable::isColumnReadOnly() is FALSE for its column, and QTable::isReadOnly() is FALSE.

QComboTableItems have an isEditable() property. This property is used to indicate whether the user may enter their own text or are restricted to choosing one of the choices in the list. QComboTableItems may be interacted with only if they are editable in accordance with their EditType as described above.

Member Function Documentation

QTableItem::QTableItem ( QTable * table, EditType et, const QString & text )

The table item will use a QLineEdit for its editor, will not word-wrap and will occupy a single cell. Insert the table item into a table with QTable::setItem().

The table takes ownership of the table item, so a table item should not be inserted into more than one table at a time.

QTableItem::QTableItem ( QTable * table, EditType et, const QString & text, const QPixmap & p )

The table item will display the pixmap to the left of the text. It will use a QLineEdit for editing the text, will not word-wrap and will occupy a single cell. Insert the table item into a table with QTable::setItem().

The table takes ownership of the table item, so a table item should not be inserted in more than one table at a time.

QTableItem::~QTableItem () [virtual]

If the table item is in a table (i.e. was inserted with setItem()), it will be removed from the table and the cell it occupied.

int QTableItem::alignment () const [virtual]

See also Qt::AlignmentFlags.

int QTableItem::col () const

See also row() and setCol().

int QTableItem::colSpan () const

See also setSpan() and rowSpan().

QWidget * QTableItem::createEditor () const [virtual]

If the function returns 0, the cell is read-only.

The returned widget should preferably be invisible, ideally with QTable::viewport() as parent.

If you reimplement this function you'll almost certainly need to reimplement setContentFromEditor(), and may need to reimplement sizeHint().

    QWidget *ComboItem::createEditor() const
    {
        // create an editor - a combobox in our case
        ( (ComboItem*)this )->cb = new QComboBox( table()->viewport() );
        QObject::connect( cb, SIGNAL( activated( int ) ), table(), SLOT( doValueChanged() ) );
        cb->insertItem( "Yes" );
        cb->insertItem( "No" );
        // and initialize it
        cb->setCurrentItem( text() == "No" ? 1 : 0 );
        return cb;

See also QTable::createEditor(), setContentFromEditor() and QTable::viewport().

Example: table/statistics/statistics.cpp.

EditType QTableItem::editType () const

This is set when the table item is constructed.

See also EditType and QTableItem().

bool QTableItem::isEnabled () const

See also setEnabled().

bool QTableItem::isReplaceable () const

(This differs from EditType because EditType is concerned with whether the user is able to change the contents of a cell.)

See also setReplaceable() and EditType.

QString QTableItem::key () const [virtual]

See also QTable::sorting.

void QTableItem::paint ( QPainter * p, const QColorGroup & cg, const QRect & cr, bool selected ) [virtual]

If selected is TRUE the cell is displayed in a way that indicates that it is highlighted.

You don't usually need to use this function but if you want to draw custom content in a cell you will need to reimplement it.

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

    p->setClipRect( table()->cellRect(row, col), QPainter::ClipPainter );
    //... your drawing code
    p->setClipping( FALSE );
    

Example: table/statistics/statistics.cpp.

QPixmap QTableItem::pixmap () const [virtual]

See also setPixmap() and text().

int QTableItem::row () const

See also col() and setRow().

int QTableItem::rowSpan () const

See also setSpan() and colSpan().

int QTableItem::rtti () const [virtual]

When you create subclasses based on QTableItem make sure that each subclass returns a unique rtti() value. It is advisable to use values greater than 1000, preferably large random numbers, to allow for extensions to this class.

See also QCheckTableItem::rtti() and QComboTableItem::rtti().

Reimplemented in QComboTableItem and QCheckTableItem.

void QTableItem::setCol ( int c ) [virtual]

If the cell spans multiple columns, this function sets the left-most column and retains the width of the multi-cell table item.

See also col(), setRow() and colSpan().

void QTableItem::setContentFromEditor ( QWidget * w ) [virtual]

If you reimplement createEditor() and return something that is not a QLineEdit you will almost certainly have to reimplement this function.

    void ComboItem::setContentFromEditor( QWidget *w )
    {
        // the user changed the value of the combobox, so synchronize the
        // value of the item (its text), with the value of the combobox
        if ( w->inherits( "QComboBox" ) )
            setText( ( (QComboBox*)w )->currentText() );
        else
            QTableItem::setContentFromEditor( w );

See also QTable::setCellContentFromEditor().

Example: table/statistics/statistics.cpp.

void QTableItem::setEnabled ( bool b ) [virtual]

A disabled item doesn't respond to user interaction.

See also isEnabled().

void QTableItem::setPixmap ( const QPixmap & p ) [virtual]

Note that setPixmap() does not update the cell the table item belongs to. Use QTable::updateCell() to repaint the cell's contents.

For QComboTableItems and QCheckTableItems this function has no visible effect.

See also QTable::setPixmap(), pixmap() and setText().

void QTableItem::setReplaceable ( bool b ) [virtual]

(This differs from EditType because EditType is concerned with whether the user is able to change the contents of a cell.)

See also isReplaceable().

void QTableItem::setRow ( int r ) [virtual]

If the cell spans multiple rows, this function sets the top row and retains the height of the multi-cell table item.

See also row(), setCol() and rowSpan().

void QTableItem::setSpan ( int rs, int cs ) [virtual]

Warning: This function only works if the item has already been inserted into the table using e.g. QTable::setItem(). This function also checks to make sure if rs and cs are within the bounds of the table and returns without changing the span if they are not.

See also rowSpan() and colSpan().

void QTableItem::setText ( const QString & str ) [virtual]

Note that setText() does not update the cell the table item belongs to. Use QTable::updateCell() to repaint the cell's contents.

See also QTable::setText(), text(), setPixmap() and QTable::updateCell().

Example: table/statistics/statistics.cpp.

void QTableItem::setWordWrap ( bool b ) [virtual]

See also wordWrap(), QTable::adjustColumn() and QTable::setColumnStretchable().

QSize QTableItem::sizeHint () const [virtual]

If you subclass QTableItem you will often need to reimplement this function.

QTable * QTableItem::table () const

Returns the QTable the table item belongs to.

See also QTable::setItem() and QTableItem().

QString QTableItem::text () const [virtual]

To ensure that the current value of the editor is returned, setContentFromEditor() is called:

1. if the editMode() is Always, or
2. if editMode() is not Always but the editor of the cell is active and the editor is not a QLineEdit.

This means that text() returns the original text value of the item if the editor is a line edit, until the user commits an edit (e.g. by pressing Enter or Tab) in which case the new text is returned. For other editors (e.g. a combobox) setContentFromEditor() is always called so the currently display value is the one returned.

See also setText() and pixmap().

bool QTableItem::wordWrap () const

See also setWordWrap().

This file is part of the Qt toolkit. Copyright © 1995-2002 Trolltech. All Rights Reserved.