qtable man page on aLinux

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

QTable(3qt)							   QTable(3qt)

NAME
       QTable - Flexible editable table widget

SYNOPSIS
       #include <qtable.h>

       Inherits QScrollView.

       Inherited by QDataTable.

   Public Members
       QTable ( QWidget * parent = 0, const char * name = 0 )
       QTable ( int numRows, int numCols, QWidget * parent = 0, const char *
	   name = 0 )
       ~QTable ()
       QHeader * horizontalHeader () const
       QHeader * verticalHeader () const
       enum SelectionMode { Single, Multi, SingleRow, MultiRow, NoSelection }
       virtual void setSelectionMode ( SelectionMode mode )
       SelectionMode selectionMode () const
       virtual void setItem ( int row, int col, QTableItem * item )
       virtual void setText ( int row, int col, const QString & text )
       virtual void setPixmap ( int row, int col, const QPixmap & pix )
       virtual QTableItem * item ( int row, int col ) const
       virtual QString text ( int row, int col ) const
       virtual QPixmap pixmap ( int row, int col ) const
       virtual void clearCell ( int row, int col )
       virtual QRect cellGeometry ( int row, int col ) const
       virtual int columnWidth ( int col ) const
       virtual int rowHeight ( int row ) const
       virtual int columnPos ( int col ) const
       virtual int rowPos ( int row ) const
       virtual int columnAt ( int x ) const
       virtual int rowAt ( int y ) const
       virtual int numRows () const
       virtual int numCols () const
       void updateCell ( int row, int col )
       int currentRow () const
       int currentColumn () const
       void ensureCellVisible ( int row, int col )
       bool isSelected ( int row, int col ) const
       bool isRowSelected ( int row, bool full = FALSE ) const
       bool isColumnSelected ( int col, bool full = FALSE ) const
       int numSelections () const
       QTableSelection selection ( int num ) const
       virtual int addSelection ( const QTableSelection & s )
       virtual void removeSelection ( const QTableSelection & s )
       virtual void removeSelection ( int num )
       virtual int currentSelection () const
       void selectCells ( int start_row, int start_col, int end_row, int
	   end_col )
       void selectRow ( int row )
       void selectColumn ( int col )
       bool showGrid () const
       bool columnMovingEnabled () const
       bool rowMovingEnabled () const
       virtual void sortColumn ( int col, bool ascending = TRUE, bool
	   wholeRows = FALSE )
       bool sorting () const
       virtual void takeItem ( QTableItem * i )
       virtual void setCellWidget ( int row, int col, QWidget * e )
       virtual QWidget * cellWidget ( int row, int col ) const
       virtual void clearCellWidget ( int row, int col )
       virtual QRect cellRect ( int row, int col ) const
       virtual void paintCell ( QPainter * p, int row, int col, const QRect &
	   cr, bool selected )
       virtual void paintCell ( QPainter * p, int row, int col, const QRect &
	   cr, bool selected, const QColorGroup & cg )
       virtual void paintFocus ( QPainter * p, const QRect & cr )
       bool isReadOnly () const
       bool isRowReadOnly ( int row ) const
       bool isColumnReadOnly ( int col ) const
       void repaintSelections ()
       enum FocusStyle { FollowStyle, SpreadSheet }
       virtual void setFocusStyle ( FocusStyle fs )
       FocusStyle focusStyle () const
       void updateHeaderStates ()

   Public Slots
       virtual void setNumRows ( int r )
       virtual void setNumCols ( int r )
       virtual void setShowGrid ( bool b )
       virtual void hideRow ( int row )
       virtual void hideColumn ( int col )
       virtual void showRow ( int row )
       virtual void showColumn ( int col )
       bool isRowHidden ( int row ) const
       bool isColumnHidden ( int col ) const
       virtual void setColumnWidth ( int col, int w )
       virtual void setRowHeight ( int row, int h )
       virtual void adjustColumn ( int col )
       virtual void adjustRow ( int row )
       virtual void setColumnStretchable ( int col, bool stretch )
       virtual void setRowStretchable ( int row, bool stretch )
       bool isColumnStretchable ( int col ) const
       bool isRowStretchable ( int row ) const
       virtual void setSorting ( bool b )
       virtual void swapRows ( int row1, int row2, bool swapHeader = FALSE )
       virtual void swapColumns ( int col1, int col2, bool swapHeader = FALSE
	   )
       virtual void swapCells ( int row1, int col1, int row2, int col2 )
       virtual void setLeftMargin ( int m )
       virtual void setTopMargin ( int m )
       virtual void setCurrentCell ( int row, int col )
       void clearSelection ( bool repaint = TRUE )
       virtual void setColumnMovingEnabled ( bool b )
       virtual void setRowMovingEnabled ( bool b )
       virtual void setReadOnly ( bool b )
       virtual void setRowReadOnly ( int row, bool ro )
       virtual void setColumnReadOnly ( int col, bool ro )
       virtual void setDragEnabled ( bool b )
       bool dragEnabled () const
       virtual void insertRows ( int row, int count = 1 )
       virtual void insertColumns ( int col, int count = 1 )
       virtual void removeRow ( int row )
       virtual void removeRows ( const QMemArray<int> & rows )
       virtual void removeColumn ( int col )
       virtual void removeColumns ( const QMemArray<int> & cols )
       virtual void editCell ( int row, int col, bool replace = FALSE )
       void setRowLabels ( const QStringList & labels )
       void setColumnLabels ( const QStringList & labels )

   Signals
       void currentChanged ( int row, int col )
       void clicked ( int row, int col, int button, const QPoint & mousePos )
       void doubleClicked ( int row, int col, int button, const QPoint &
	   mousePos )
       void pressed ( int row, int col, int button, const QPoint & mousePos )
       void selectionChanged ()
       void valueChanged ( int row, int col )
       void contextMenuRequested ( int row, int col, const QPoint & pos )
       void dropped ( QDropEvent * e )

   Properties
       bool columnMovingEnabled - whether columns can be moved by the user
       FocusStyle focusStyle - how the current (focus) cell is drawn
       int numCols - the number of columns in the table
       int numRows - the number of rows in the table
       int numSelections - the number of selections  (read only)
       bool readOnly - whether the table is read-only
       bool rowMovingEnabled - whether rows can be moved by the user
       SelectionMode selectionMode - the current selection mode
       bool showGrid - whether the table's grid is displayed
       bool sorting - whether a click on the header of a column sorts that
	   column

   Protected Members
       enum EditMode { NotEditing, Editing, Replacing }
       virtual void drawContents ( QPainter * p, int cx, int cy, int cw, int
	   ch )
       void setEditMode ( EditMode mode, int row, int col )
       virtual void contentsDragEnterEvent ( QDragEnterEvent * e )
       virtual void contentsDragMoveEvent ( QDragMoveEvent * e )
       virtual void contentsDragLeaveEvent ( QDragLeaveEvent * e )
       virtual void contentsDropEvent ( QDropEvent * e )
       virtual QDragObject * dragObject ()
       virtual void startDrag ()
       virtual void paintEmptyArea ( QPainter * p, int cx, int cy, int cw, int
	   ch )
       virtual void activateNextCell ()
       virtual QWidget * createEditor ( int row, int col, bool initFromCell )
	   const
       virtual void setCellContentFromEditor ( int row, int col )
       virtual QWidget * beginEdit ( int row, int col, bool replace )
       virtual void endEdit ( int row, int col, bool accept, bool replace )
       virtual void resizeData ( int len )
       virtual void insertWidget ( int row, int col, QWidget * w )
       int indexOf ( int row, int col ) const
       bool isEditing () const
       EditMode editMode () const
       int currEditRow () const
       int currEditCol () const

   Protected Slots
       virtual void columnWidthChanged ( int col )
       virtual void rowHeightChanged ( int row )
       virtual void columnIndexChanged ( int section, int fromIndex, int
	   toIndex )
       virtual void rowIndexChanged ( int section, int fromIndex, int toIndex
	   )
       virtual void columnClicked ( int col )

DESCRIPTION
       The QTable class provides a flexible editable table widget.

       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>
				   [Image Omitted]

       </center>

Headers
       QTable 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 QHeader::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 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
       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().

       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
       All of a QTable's cells are empty when the table is constructed.

       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" ) );
       In the example above we create a column of QCheckTableItems and insert
       them into the table using setItem().

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

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

       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
       Specifies how the current cell (focus cell) is drawn.

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

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

QTable::QTable ( 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 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 ()
       Releases all the resources used by the QTable object, including all
       QTableItems and their widgets.

void QTable::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 QTable::addSelection ( const QTableSelection & 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 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]
       Resizes column col so that the column width is wide enough to display
       the widest item the column contains.

       See also adjustRow().

       Example: regexptester/regexptester.cpp.

       Reimplemented in QDataTable.

void QTable::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 * QTable::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 QTable::cellGeometry ( int row, int col ) const [virtual]
       Returns the bounding rectangle of the cell at row, col in content
       coordinates.

QRect QTable::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().

       Example: chart/setdataform.cpp.

QWidget * QTable::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 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]
       Removes the QTableItem at row, col.

       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]
       Removes the widget (if there is one) set for the cell at row, col.

       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]
       Clears all selections and repaints the appropriate regions if repaint
       is TRUE.

       See also removeSelection().

void QTable::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::ButtonState.

       Example: chart/setdataform.cpp.

int QTable::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 QTable::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 QTable::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 QHeader::indexChange() and rowIndexChanged().

bool QTable::columnMovingEnabled () const
       Returns TRUE if columns can be moved by the user; otherwise returns
       FALSE. See the "columnMovingEnabled" property for details.

int QTable::columnPos ( int col ) const [virtual]
       Returns the x-coordinate of the column col in content coordinates.

       See also columnAt() and rowPos().

int QTable::columnWidth ( int col ) const [virtual]
       Returns the width of column col.

       See also setColumnWidth() and rowHeight().

void QTable::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 QTable::contentsDragEnterEvent ( QDragEnterEvent * e ) [virtual
       protected]
       This event handler is called whenever a QTable 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 QScrollView.

void QTable::contentsDragLeaveEvent ( QDragLeaveEvent * e ) [virtual
       protected]
       This event handler is called when a drag activity leaves this QTable
       object with event e.

       Reimplemented from QScrollView.

void QTable::contentsDragMoveEvent ( QDragMoveEvent * e ) [virtual protected]
       This event handler is called whenever a QTable 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 QScrollView.

void QTable::contentsDropEvent ( QDropEvent * e ) [virtual protected]
       This event handler is called when the user ends a drag and drop by
       dropping something onto this QTable and thus triggers the drop event,
       e.

       Reimplemented from QScrollView.

void QTable::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 * QTable::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 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)
       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 QTableItem::createEditor().

int QTable::currEditCol () const [protected]
       Returns the current edited column

int QTable::currEditRow () const [protected]
       Returns the current edited row

void QTable::currentChanged ( int row, int col ) [signal]
       This signal is emitted when the current cell has changed to row, col.

       Example: chart/setdataform.cpp.

int QTable::currentColumn () const
       Returns the current column.

       See also currentRow().

       Example: chart/setdataform.cpp.

int QTable::currentRow () const
       Returns the current row.

       See also currentColumn().

       Example: chart/setdataform.cpp.

int QTable::currentSelection () const [virtual]
       Returns the number of the current selection or -1 if there is no
       current selection.

       See also numSelections.

void QTable::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::ButtonState.

bool QTable::dragEnabled () const [slot]
       If this function returns TRUE, the table supports dragging.

       See also setDragEnabled().

QDragObject * QTable::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 QDragObject depending on the selected items.

       See also dropped().

void QTable::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 QScrollView.

void QTable::dropped ( QDropEvent * e ) [signal]
       This signal is emitted when a drop event occurred on the table.

       e contains information about the drop.

void QTable::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 QTable::editMode () const [protected]
       Returns the current edit mode

       See also QTable::EditMode.

void QTable::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 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 )
       Scrolls the table until the cell at row, col becomes visible.

FocusStyle QTable::focusStyle () const
       Returns how the current (focus) cell is drawn. See the "focusStyle"
       property for details.

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

       See also showColumn() and hideRow().

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

       See also showRow() and hideColumn().

QHeader * QTable::horizontalHeader () const
       Returns the table's top QHeader.

       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]
       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 QIntDict to map integers to the cells that are used.

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

bool QTable::isColumnHidden ( int col ) const [slot]
       Returns TRUE if column col is hidden; otherwise returns FALSE.

       See also hideColumn() and isRowHidden().

bool QTable::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 QTableItem::EditType.

       See also setColumnReadOnly() and isRowReadOnly().

bool QTable::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 QTable::isColumnStretchable ( int col ) const [slot]
       Returns TRUE if column col is stretchable; otherwise returns FALSE.

       See also setColumnStretchable() and isRowStretchable().

bool QTable::isEditing () const [protected]
       Returns TRUE if the EditMode is Editing or Replacing; otherwise (i.e.
       the EditMode is NotEditing) returns FALSE.

       See also QTable::EditMode.

bool QTable::isReadOnly () const
       Returns TRUE if the table is read-only; otherwise returns FALSE. See
       the "readOnly" property for details.

bool QTable::isRowHidden ( int row ) const [slot]
       Returns TRUE if row row is hidden; otherwise returns FALSE.

       See also hideRow() and isColumnHidden().

bool QTable::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 QTableItem::EditType.

       See also setRowReadOnly() and isColumnReadOnly().

bool QTable::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 QTable::isRowStretchable ( int row ) const [slot]
       Returns TRUE if row row is stretchable; otherwise returns FALSE.

       See also setRowStretchable() and isColumnStretchable().

bool QTable::isSelected ( int row, int col ) const
       Returns TRUE if the cell at row, col is selected; otherwise returns
       FALSE.

       See also isRowSelected() and isColumnSelected().

QTableItem * QTable::item ( int row, int col ) const [virtual]
       Returns the QTableItem 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 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]
       Returns the number of columns in the table. See the "numCols" property
       for details.

       Reimplemented in QDataTable.

int QTable::numRows () const [virtual]
       Returns the number of rows in the table. See the "numRows" property for
       details.

       Reimplemented in QDataTable.

int QTable::numSelections () const
       Returns the number of selections. See the "numSelections" property for
       details.

void QTable::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 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]
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       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]
       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 QTable::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 QTable::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().

       Example: chart/setdataform.cpp.

void QTable::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::ButtonState.

void QTable::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 QTable::removeColumns ( const QMemArray<;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 QTable::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 QTable::removeRows ( const QMemArray<;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 QTable::removeSelection ( const QTableSelection & s ) [virtual]
       If the table has a selection, s, this selection is removed from the
       table.

       See also addSelection() and numSelections.

void QTable::removeSelection ( int num ) [virtual]
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Removes selection number num from the table.

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

void QTable::repaintSelections ()
       Repaints all selections

void QTable::resizeData ( int len ) [virtual protected]
       This is called when QTable's internal array needs to be resized to len
       elements.

       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]
       Returns the number of the row at position y. y must be given in content
       coordinates.

       See also rowPos() and columnAt().

int QTable::rowHeight ( int row ) const [virtual]
       Returns the height of row row.

       See also setRowHeight() and columnWidth().

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

void QTable::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 QTable::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 QHeader::indexChange() and columnIndexChanged().

bool QTable::rowMovingEnabled () const
       Returns TRUE if rows can be moved by the user; otherwise returns FALSE.
       See the "rowMovingEnabled" property for details.

int QTable::rowPos ( int row ) const [virtual]
       Returns the y-coordinate of the row row in content coordinates.

       See also rowAt() and columnPos().

void QTable::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 QTableSelection.

void QTable::selectColumn ( int col )
       Selects the column col.

       See also QTableSelection.

void QTable::selectRow ( int row )
       Selects the row row.

       See also QTableSelection.

QTableSelection QTable::selection ( int num ) const
       Returns selection number num, or an inactive QTableSelection if num is
       out of range (see QTableSelection::isActive()).

void QTable::selectionChanged () [signal]
       This signal is emitted whenever a selection changes.

       See also QTableSelection.

SelectionMode QTable::selectionMode () const
       Returns the current selection mode. See the "selectionMode" property
       for details.

void QTable::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 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]
       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.

       Example: chart/setdataform.cpp.

void QTable::setColumnLabels ( const QStringList & labels ) [slot]
       Sets the section labels of the horizontalHeader() to labels

void QTable::setColumnMovingEnabled ( bool b ) [virtual slot]
       Sets whether columns can be moved by the user to b. See the
       "columnMovingEnabled" property for details.

void QTable::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 QTableItem::EditType.

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

       Example: chart/setdataform.cpp.

void QTable::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 QTable::setColumnWidth ( int col, int w ) [virtual slot]
       Resizes column col to be w pixels wide.

       See also columnWidth() and setRowHeight().

       Example: chart/setdataform.cpp.

       Reimplemented in QDataTable.

void QTable::setCurrentCell ( int row, int col ) [virtual slot]
       Moves the focus to the cell at row, col.

       See also currentRow() and currentColumn().

void QTable::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.

void QTable::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.

void QTable::setFocusStyle ( FocusStyle fs ) [virtual]
       Sets how the current (focus) cell is drawn to fs. See the "focusStyle"
       property for details.

void QTable::setItem ( int row, int col, QTableItem * 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 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]
       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().

       Example: regexptester/regexptester.cpp.

void QTable::setNumCols ( int r ) [virtual slot]
       Sets the number of columns in the table to r. See the "numCols"
       property for details.

void QTable::setNumRows ( int r ) [virtual slot]
       Sets the number of rows in the table to r. See the "numRows" property
       for details.

void QTable::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 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]
       Sets whether the table is read-only to b. See the "readOnly" property
       for details.

void QTable::setRowHeight ( int row, int h ) [virtual slot]
       Resizes row row to be h pixels high.

       See also rowHeight() and setColumnWidth().

void QTable::setRowLabels ( const QStringList & labels ) [slot]
       Sets the section labels of the verticalHeader() to labels

void QTable::setRowMovingEnabled ( bool b ) [virtual slot]
       Sets whether rows can be moved by the user to b. See the
       "rowMovingEnabled" property for details.

void QTable::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 QTableItem::EditType.

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

void QTable::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 QTable::setSelectionMode ( SelectionMode mode ) [virtual]
       Sets the current selection mode to mode. See the "selectionMode"
       property for details.

void QTable::setShowGrid ( bool b ) [virtual slot]
       Sets whether the table's grid is displayed to b. See the "showGrid"
       property for details.

void QTable::setSorting ( bool b ) [virtual slot]
       Sets whether a click on the header of a column sorts that column to b.
       See the "sorting" property for details.

void QTable::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 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]
       Sets the top margin to be m pixels high.

       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]
       Shows column col.

       See also hideColumn() and showRow().

bool QTable::showGrid () const
       Returns TRUE if the table's grid is displayed; otherwise returns FALSE.
       See the "showGrid" property for details.

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

       See also hideRow() and showColumn().

void QTable::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 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
       Returns TRUE if a click on the header of a column sorts that column;
       otherwise returns FALSE. See the "sorting" property for details.

void QTable::startDrag () [virtual protected]
       Starts a drag.

       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]
       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 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]
       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 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]
       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 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]
       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 QTable::text ( int row, int col ) const [virtual]
       Returns the text in the cell at row, col, or QString::null if the
       relevant item does not exist or has no text.

       See also setText() and setPixmap().

       Example: chart/setdataform.cpp.

       Reimplemented in QDataTable.

void QTable::updateCell ( int row, int col )
       Repaints the cell at row, col.

void QTable::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 QTable::valueChanged ( int row, int col ) [signal]
       This signal is emitted when the user changed the value in the cell at
       row, col.

       Example: chart/setdataform.cpp.

QHeader * QTable::verticalHeader () const
       Returns the table's vertical QHeader.

       This header contains the row labels.

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

       Examples:

   Property Documentation
bool columnMovingEnabled
       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.

       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
       This property holds how the current (focus) cell is drawn.

       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
       This property holds the number of columns in the table.

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

       See also numRows.

int numRows
       This property holds the number of rows in the table.

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

       See also numCols.

int numSelections
       This property holds the number of selections.

       Get this property's value with numSelections().

       See also currentSelection().

bool readOnly
       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: 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
       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.

       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
       This property holds the current selection mode.

       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
       This property holds whether the table's grid is displayed.

       The grid is shown by default.

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

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

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

       See also sortColumn().

SEE ALSO
       http://doc.trolltech.com/qtable.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
       (qtable.3qt) and the Qt version (3.3.8).

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

List of man pages available for aLinux

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