qtableitem man page on Peanut

Man page or keyword search:  
man Server   7435 pages
apropos Keyword Search (all sections)
Output format
Peanut logo
[printable version]

QTableItem(3qt)						       QTableItem(3qt)

NAME
       QTableItem - The cell content for QTable cells

SYNOPSIS
       #include <qtable.h>

       Inherits Qt.

       Inherited by QComboTableItem and QCheckTableItem.

   Public Members
       enum EditType { Never, OnTyping, WhenCurrent, Always }
       QTableItem ( QTable * table, EditType et )
       QTableItem ( QTable * table, EditType et, const QString & text )
       QTableItem ( QTable * table, EditType et, const QString & text, const
	   QPixmap & p )
       virtual ~QTableItem ()
       virtual QPixmap pixmap () const
       virtual QString text () const
       virtual void setPixmap ( const QPixmap & p )
       virtual void setText ( const QString & str )
       QTable * table () const
       virtual int alignment () const
       virtual void setWordWrap ( bool b )
       bool wordWrap () const
       EditType editType () const
       virtual QWidget * createEditor () const
       virtual void setContentFromEditor ( QWidget * w )
       virtual void setReplaceable ( bool b )
       bool isReplaceable () const
       virtual QString key () const
       virtual QSize sizeHint () const
       virtual void setSpan ( int rs, int cs )
       int rowSpan () const
       int colSpan () const
       virtual void setRow ( int r )
       virtual void setCol ( int c )
       int row () const
       int col () const
       virtual void paint ( QPainter * p, const QColorGroup & cg, const QRect
	   & cr, bool selected )
       virtual void setEnabled ( bool b )
       bool isEnabled () const
       virtual int rtti () const

DESCRIPTION
       The QTableItem class provides the cell content for QTable cells.

       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.

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

       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, QTableItem::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.

       Note, that if you have a table item that is not currently in a table
       then anything you do to that item other than insert it into a table
       will result in undefined behaviour.

       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.

       It is important to ensure that your custom widget can accept the
       keyboard focus, so that the user can use the tab key to navigate the
       table as normal. Therefore, if the widget returned by createEditor()
       does not itself accept the keyboard focus, it is necessary to nominate
       a child widget to do so on its behalf. For example, a QHBox with two
       child QLineEdit widgets may use one of them to accept the keyboard
       focus:

	   QWidget* MyTableItem::createEditor() const
	   {
	       QHBox* hbox = new QHBox( table()->viewport() );
	       hbox->setFocusProxy(new QLineEdit( hbox ));
	       new QLineEdit( hbox );
	       return hbox;
	   }

       By default, table items may be replaced by new QTableItems during the
       lifetime of a QTable. Therefore, if you create your own subclass of
       QTableItem, and you want to ensure that this does not happen, you must
       call setReplaceable(FALSE) in the constructor of your subclass.

       <center>
				   [Image Omitted]

       </center>

       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 )
       Creates a table item that is a child of table table with no text. The
       item has the EditType et.

       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 )
       Creates a table item that is a child of table table with text text. The
       item has the EditType et.

       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 )
       Creates a table item that is a child of table table with text text and
       pixmap p. The item has the EditType et.

       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]
       The destructor deletes this item and frees all allocated resources.

       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]
       The alignment function returns how the text contents of the cell are
       aligned when drawn. The default implementation aligns numbers to the
       right and any other text to the left.

       See also Qt::AlignmentFlags.

int QTableItem::col () const
       Returns the column where the table item is located. If the cell spans
       multiple columns, this function returns the left-most column.

       See also row() and setCol().

       Example: table/bigtable/main.cpp.

int QTableItem::colSpan () const
       Returns the column span of the table item, usually 1.

       See also setSpan() and rowSpan().

QWidget * QTableItem::createEditor () const [virtual]
       This virtual function creates an editor which the user can interact
       with to edit the cell's contents. The default implementation creates a
       QLineEdit.

       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(),
       QTable::viewport(), and setReplaceable().

       Example: table/statistics/statistics.cpp.

EditType QTableItem::editType () const
       Returns the table item's edit type.

       This is set when the table item is constructed.

       See also EditType and QTableItem().

bool QTableItem::isEnabled () const
       Returns TRUE if the table item is enabled; otherwise returns FALSE.

       See also setEnabled().

bool QTableItem::isReplaceable () const
       This function returns whether the contents of the cell may be replaced
       with the contents of another table item. Regardless of this setting,
       table items that span more than one cell may not have their contents
       replaced by another table item.

       (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]
       This virtual function returns the key that should be used for sorting.
       The default implementation returns the text() of the relevant item.

       See also QTable::sorting.

void QTableItem::paint ( QPainter * p, const QColorGroup & cg, const QRect &
       cr, bool selected ) [virtual]
       This virtual function is used to paint the contents of an item using
       the painter p in the rectangular area cr using the color group cg.

       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.

       The painter passed to this function is translated so that 0, 0 is the
       top-left corner of the item that is being painted.

       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]
       Returns the table item's pixmap or a null pixmap if no pixmap has been
       set.

       See also setPixmap() and text().

int QTableItem::row () const
       Returns the row where the table item is located. If the cell spans
       multiple rows, this function returns the top-most row.

       See also col() and setRow().

       Example: table/bigtable/main.cpp.

int QTableItem::rowSpan () const
       Returns the row span of the table item, usually 1.

       See also setSpan() and colSpan().

int QTableItem::rtti () const [virtual]
       Returns the Run Time Type Identification value for this table item
       which for QTableItems is 0.

       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]
       Sets column c as the table item's column. Usually you will not need to
       call this function.

       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]
       Whenever the content of a cell has been edited by the editor w, QTable
       calls this virtual function to copy the new values into the QTableItem.

       If you reimplement createEditor() and return something that is not a
       QLineEdit you will need 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]
       If b is TRUE, the table item is enabled; if b is FALSE the table item
       is disabled.

       A disabled item doesn't respond to user interaction.

       See also isEnabled().

void QTableItem::setPixmap ( const QPixmap & p ) [virtual]
       Sets pixmap p to be this item's pixmap.

       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]
       If b is TRUE it is acceptable to replace the contents of the cell with
       the contents of another QTableItem. If b is FALSE the contents of the
       cell may not be replaced by the contents of another table item. Table
       items that span more than one cell may not have their contents replaced
       by another table item.

       (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]
       Sets row r as the table item's row. Usually you do not need to call
       this function.

       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]
       Changes the extent of the QTableItem so that it spans multiple cells
       covering rs rows and cs columns. The top left cell is the original
       cell.

       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. In addition
       swapping, inserting or removing rows and columns that cross QTableItems
       spanning more than one cell is not supported.

       See also rowSpan() and colSpan().

void QTableItem::setText ( const QString & str ) [virtual]
       Changes the table item's text to str.

       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]
       If b is TRUE, the cell's text will be wrapped over multiple lines, when
       necessary, to fit the width of the cell; otherwise the text will be
       written as a single line.

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

QSize QTableItem::sizeHint () const [virtual]
       This virtual function returns the size a cell needs to show its entire
       content.

       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]
       Returns the text of the table item or QString::null if there is no
       text.

       To ensure that the current value of the editor is returned,
       setContentFromEditor() is called: <ol type=1>

       if the editMode() is Always, or

       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
       Returns TRUE if word wrap is enabled for the cell; otherwise returns
       FALSE.

       See also setWordWrap().

SEE ALSO
       http://doc.trolltech.com/qtableitem.html
       http://www.trolltech.com/faq/tech.html

COPYRIGHT
       Copyright 1992-2007 Trolltech ASA, http://www.trolltech.com.  See the
       license file included in the distribution for a complete license
       statement.

AUTHOR
       Generated automatically from the source code.

BUGS
       If you find a bug in Qt, please report it as described in
       http://doc.trolltech.com/bughowto.html.	Good bug reports help us to
       help you. Thank you.

       The definitive Qt documentation is provided in HTML format; it is
       located at $QTDIR/doc/html and can be read using Qt Assistant or with a
       web browser. This man page is provided as a convenience for those users
       who prefer man pages, although this format is not officially supported
       by Trolltech.

       If you find errors in this manual page, please report them to qt-
       bugs@trolltech.com.  Please include the name of the manual page
       (qtableitem.3qt) and the Qt version (3.3.8).

Trolltech AS			2 February 2007		       QTableItem(3qt)
[top]

List of man pages available for Peanut

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net