QTable(3qt)QTable(3qt)NAME
QTable - A flexible and editable table widget
#include <qtable.h>
Inherits QScrollView.
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, 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 pos ) const
virtual int rowAt ( int pos ) const
int numRows () const
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
bool showGrid () const
bool columnMovingEnabled () const
bool rowMovingEnabled () const
virtual void sortColumn ( int col, bool ascending = TRUE,
Trolltech AS 13 June 2001 1
QTable(3qt)QTable(3qt)
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 void paintCell ( QPainter * p, int row, int col,
const QRect & cr, bool selected )
virtual void paintFocus ( QPainter * p, const QRect & r )
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 )
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 )
virtual void swapColumns ( int col1, int col2 )
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 )
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 )
Protected Members
virtual void drawContents ( QPainter * p, int cx, int cy,
int cw, int ch )
Trolltech AS 13 June 2001 2
QTable(3qt)QTable(3qt)
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
Protected Slots
virtual void columnWidthChanged ( int col )
virtual void rowHeightChanged ( int row )
virtual void columnIndexChanged ( int s, int oi, int ni )
virtual void rowIndexChanged ( int s, int oi, int ni )
virtual void columnClicked ( int col )
Properties
Type Name READ WRITE Options
------------------------------------------------------------------------------------
int numRows numRows setNumRows
int numCols numCols setNumCols
bool showGrid showGrid setShowGrid
bool rowMovingEnabled rowMovingEnabled setRowMovingEnabled
bool columnMovingEnabled columnMovingEnabled setColumnMovingEnabled
DESCRIPTION
A flexible and editable table widget.
QTable has been designed to use no more memory than
strictly needed. Thus, for an empty cell, no memory at all
is allocated. In order to add data, create a QTableItem
and fill it using setItem(). With QTableItem::setText()
and QTableItem::setPixmap(), convenient functions for
setting table text and pixmaps are provided. To clear a
cell use clearCell().
QTable supports various methods for selecting cells, both
with keyboard and mouse, thus for example range selection
or column and row selection via appropriate header cells.
You can add and remove selections using addSelection() and
removeSelection(), resp., and gather information about
current selections by means of numSelections(),
selection(), and currentChanged().
QTable also offers an API for sorting columns. See
setSorting(), sortColumn() and QTableItem::key() for
details.
Trolltech AS 13 June 2001 3
QTable(3qt)QTable(3qt)
Cell editing can be done in two different ways: Either you
offer an edit widget the user can use to enter data that
should replace the current content, or you provide him or
her with an editor to change the data stored in the cell.
If you won't allow the content of a cell to be replaced,
however make it possible to edit the current data, simply
set QTableItem::isReplaceable() to FALSE.
When a user starts typing text in-place editing
(replacing) for the current cell is invoked. Additionally,
in-place editing (editing) starts as soon as he or she
double-clicks a cell. Sometimes, however, it is required
that a cell always shows an editor, that the editor shows
off as soon as the relevant cell receives the focus, or
that the item shouldn't be edited at all. This edit type
has to be specified in the constructor of a QTableItem.
In-place editing is invoked by beginEdit(). This function
creates the editor widget for the required cell (see
createEditor() for detailed information) and shows it at
the appropriate location.
As soon as the user finishes editing endEdit() is called.
Have a look at the endEdit() documentation for further
information e.g. on how content is transferred from the
editor to the item or how the editor is destroyed.
In-place editing is implemented in an abstract way to make
sure custom edit widgets for certain cells or cell types
can be written easily. To obtain this it is possible to
place widgets in cells. See setCellWidget(),
clearCellWidget() and cellWidget() for further details.
In order to prevent a cell not containing a QTableItem
from being edited, you have to reimplement createEditor().
This function should return 0 for cells that must be not
edited at all.
It is possible to use QTable without QTableItems. However,
as the default implementation of QTable's in-place editing
uses QTableItems, you will have to reimplement
createEditor() and setCellContentFromEditor() to get in-
place editing without QTableItems. The documentation of
these two functions explains the details you need to know
for that matter.
In order to draw custom content in a cell you have to
implement your own subclass of QTableItem and reimplement
the QTableItem::paint() method.
If your application stores its data already in a way that
allocating a QTableItem for each data containing cell
seems inappropriate, you can reimplement
QTable::paintCell() and draw the contents directly. You
Trolltech AS 13 June 2001 4
QTable(3qt)QTable(3qt)
should also reimplement QTable::paintCell() if you wish to
change the alignment of your items in the QTable.
Unless you reimplement them this approach will however
prevent you from using functions like setText() etc.
Remember that in this case, repainting the cells using
updateCell() after each change made is necessary. To make
sure you don't waste memory, read the documentation of
resizeData().
Member Type Documentation
QTable::SelectionMode
NoSelection - No cell can be selected by the user.
Single - The user may select one range of cells only.
Multi - Multi-range selections are possible.
MEMBER FUNCTION DOCUMENTATIONQTable::QTable ( QWidget * parent = 0, const char * name = 0 )
Constructs a table of 10 * 10 cells.
Performance is boosted by modifying the widget flags so
that only part of the QTableItem children is redrawn. This
may be unsuitable for custom QTableItem classes, in which
case WNorthWestGravity and WRepaintNoErase should be
cleared.
See also QWidget::clearWFlags() and Qt::WidgetFlags.
QTable::QTable ( int numRows, int numCols, QWidget * parent = 0,
const char * name = 0 )
Constructs a table with a range of numRows * numCols
cells.
Performance is boosted by modifying the widget flags so
that only part of the QTableItem children is redrawn. This
may be unsuitable for custom QTableItem classes, in which
case the widget flags should be reset using
QWidget::setWFlags().
QTable::~QTable ()
Destructor.
void QTable::activateNextCell () [virtual protected]
This is called to activate the next cell if in-place
editing was finished by pressing the Return key.
If you want a different behaviour then going from top to
bottom, reimplement this function.
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. Don't forget
Trolltech AS 13 June 2001 5
QTable(3qt)QTable(3qt)
to call QTableSelection::init() and
QTableSelection::expandTo() to make it valid (see also
QTableSelection::isActive()).
void QTable::adjustColumn ( int col ) [virtual slot]
Resizes the column col to be exactly wide enough so that
the whole contents is visible.
void QTable::adjustRow ( int row ) [virtual slot]
Resizes the row row to be exactly high enough so that the
whole contents is visible.
QWidget * QTable::beginEdit ( int row, int col, bool replace )
[virtual protected]
This function is called to start in-place editing of the
cell row, col. If replace is TRUE the content of this cell
will be replaced by the content of the editor later, else
the current content of that cell (if existing) will be
edited by the editor.
This function calls createEditor() to get the editor which
should be used for editing the cell and after that
setCellWidget() to set this editor as the widget of that
cell.
See also createEditor(), setCellWidget() and endEdit().
QRect QTable::cellGeometry ( int row, int col ) const [virtual]
Returns the bounding rect of the cell row, col in contents
coordinates.
QWidget * QTable::cellWidget ( int row, int col ) const [virtual]
Returns the widget which has been set to the cell row, col
of 0 if there is no widget.
void QTable::clearCell ( int row, int col ) [virtual]
Removes the QTableItem in position row, col.
void QTable::clearCellWidget ( int row, int col ) [virtual]
Removes the widget (if there is any) which is set for the
cell row, col.
void QTable::clearSelection ( bool repaint = TRUE ) [slot]
Clears all selections.
void QTable::clicked ( int row, int col, int button, const QPoint
& mousePos ) [signal]
This signal is emitted as soon as a user clicks on row and
col using mousebutton button. The actual mouse position is
passed as mousePos.
int QTable::columnAt ( int pos ) const [virtual]
Returns the column which is at pos. pos has to be given in
contents coordinates.
Trolltech AS 13 June 2001 6
QTable(3qt)QTable(3qt)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, int, int ) [virtual
protected slot]
This function is called if the order of the columns has
been changed. If you want to change the order
programmatically, call swapRows() or swapColumns().
bool QTable::columnMovingEnabled () const
Returns whether columns can be moved by the user.
int QTable::columnPos ( int col ) const [virtual]
Returns the x-position of the column col in contents
coordinates.
int QTable::columnWidth ( int col ) const [virtual]
Returns the width of the column col.
void QTable::columnWidthChanged ( int col ) [virtual protected
slot]
This function should be called whenever the column width
of col has been changed. It will then rearrange the
content appropriately.
void QTable::contentsMouseDoubleClickEvent ( QMouseEvent * e )
[virtual protected]
Reimplemented for internal reasons; the API is not
affected.
Reimplemented from QScrollView.
void QTable::contentsMouseMoveEvent ( QMouseEvent * e ) [virtual
protected]
Reimplemented for internal reasons; the API is not
affected.
Reimplemented from QScrollView.
void QTable::contentsMousePressEvent ( QMouseEvent * e ) [virtual
protected]
Reimplemented for internal reasons; the API is not
affected.
Reimplemented from QScrollView.
void QTable::contentsMouseReleaseEvent ( QMouseEvent * e )
[virtual protected]
Reimplemented for internal reasons; the API is not
affected.
Reimplemented from QScrollView.
Trolltech AS 13 June 2001 7
QTable(3qt)QTable(3qt)QWidget * QTable::createEditor ( int row, int col, bool
initFromCell ) const [virtual protected]
This function returns a widget which should be used as
editor for the cell row, col. If initFromCell is TRUE, the
editor is used to edit the current content of the cell (so
the editor widget should be initialized with that
content). Otherwise the content of this cell will be
replaced by a new content which the user will enter into
the widget which this function should create.
The default implementation looks if there exists a
QTableItem for the cell. If this is the case and
initFromCell is TRUE or QTableItem::isReplaceable() of the
item is FALSE, the item of that cell is asked to create
the editor (using QTableItem::createEditor)).
If this is not the case, a QLineEdit is created as editor.
So if you want to create your own editor for certain
cells, implement your own QTableItem and reimplement
QTableItem::createEditor(). If you want to use a different
editor than a QLineEdit as default editor, reimplement
this function and use a code like
QTableItem *i = item( row, col );
if ( initFromCell || i && !i->isReplaceable() )
return QTable::createEditor( row, col, initFromCell );
else
return ...(create your editor)
So normally you do not need to reimplement this function.
But if you want e.g. work without QTableItems, you will
reimplement this function to create the correct editor for
the cells.
The ownership of the editor widget is transferred to the
caller.
Returning 0 here means that the cell is not editable.
See also QTableItem::createEditor().
void QTable::currentChanged ( int row, int col ) [signal]
This signal is emitted if the current cell has been
changed to row, col.
int QTable::currentColumn () const
Returns the current column.
int QTable::currentRow () const
Returns the current row.
int QTable::currentSelection () const [virtual]
Returns the number of the current selection or -1 if there
Trolltech AS 13 June 2001 8
QTable(3qt)QTable(3qt)
is none.
void QTable::doubleClicked ( int row, int col, int button, const
QPoint & mousePos ) [signal]
A double-click with button emits this signal, where row
and col denote the position of the cell. The actual mouse
position is passed as mousePos.
void QTable::drawContents ( QPainter * p, int cx, int cy, int cw,
int ch ) [virtual protected]
Draws the table contents on the painter p. The function is
optimized to exclusively draw the cells inside the
relevant clipping rectangle cx, cy, cw, ch.
Additionally, drawContents() highlights the current cell.
Reimplemented from QScrollView.
void QTable::endEdit ( int row, int col, bool accept, bool
replace ) [virtual protected]
This function is called if in-place editing of the cell
row, col has to be ended. If accept is TRUE the content of
the editor of this cell has to be transferred to the cell.
If replace is TRUE the current content of that 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), else (if possible) the content of
the editor should just be set to the existing QTableItem
of this cell.
So, if the cell contents should be replaced or if no
QTableItem exists for the cell yet,
setCellContentFromEditor() is called, else
QTableItem::setContentFromEditor() is called on the
QTableItem of the cell.
After that clearCellWidget() is called to get rid of the
editor widget.
See also setCellContentFromEditor() and beginEdit().
void QTable::ensureCellVisible ( int row, int col )
Scrolls the table until the cell row, col becomes visible.
bool QTable::eventFilter ( QObject * o, QEvent * e ) [virtual]
Reimplemented for internal reasons; the API is not
affected.
Reimplemented from QObject.
void QTable::focusInEvent ( QFocusEvent * ) [virtual protected]
Reimplemented for internal reasons; the API is not
affected.
Trolltech AS 13 June 2001 9
QTable(3qt)QTable(3qt)
Reimplemented from QWidget.
void QTable::focusOutEvent ( QFocusEvent * ) [virtual protected]
Reimplemented for internal reasons; the API is not
affected.
Reimplemented from QWidget.
void QTable::hideColumn ( int col ) [virtual slot]
Hides the column col.
See also showCol().
void QTable::hideRow ( int row ) [virtual slot]
Hides the row row.
See also showRow().
QHeader * QTable::horizontalHeader () const
Returns the top QHeader of the table.
int QTable::indexOf ( int row, int col ) const [protected]
Maps 2D table to 1D array index.
void QTable::insertWidget ( int row, int col, QWidget * w )
[virtual protected]
Inserts the widget w into the internal datastructure. See
the documentation of setCellWidget() for further details.
bool QTable::isColumnSelected ( int col, bool full = FALSE )
const
Returns TRUE if column col is selected, and FALSE
otherwise.
If full is TRUE, the entire column must be selected for
this function to return TRUE. If full is FALSE, at least
one cell in col must be selected.
bool QTable::isColumnStretchable ( int col ) const [slot]
Returns wheather the column col is stretchable or not.
See also setColumnStretchable().
bool QTable::isRowSelected ( int row, bool full = FALSE ) const
Returns TRUE if row is selected, and FALSE otherwise.
If full is TRUE, the entire row must be selected for this
function to return TRUE. If full is FALSE, at least one
cell in row must be selected.
bool QTable::isRowStretchable ( int row ) const [slot]
Returns wheather the row row is stretchable or not.
See also setRowStretchable().
Trolltech AS 13 June 2001 10
QTable(3qt)QTable(3qt)bool QTable::isSelected ( int row, int col ) const
Checks whether the cell at position row, col is selected.
QTableItem * QTable::item ( int row, int col ) const [virtual]
Returns the QTableItem representing the contents of the
cell row, col. If row or col are out of range or no
content has been set for this cell so far, item() returns
0.
void QTable::keyPressEvent ( QKeyEvent * e ) [virtual protected]
Reimplemented for internal reasons; the API is not
affected.
Reimplemented from QWidget.
int QTable::numCols () const
Returns the number of columns of the table.
int QTable::numRows () const
Returns the number of rows of the table.
int QTable::numSelections () const
Returns the number of selections.
void QTable::paintCell ( QPainter * p, int row, int col, const
QRect & cr, bool selected ) [virtual]
Paints the cell at the position 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 you want to draw custom cell content you have to
reimplement paintCell() to do the custom drawing, or else
subclass QTableItem and reimplement QTableItem::paint().
If you want to change the alignment of your items then you
will need to reimplement paintCell().
Reimplementing this function is probably better e.g. for
data you retrieve from a database and draw at once, while
using QTableItem::paint() is probably better e.g. if you
wish these data to be stored in a data structure in the
table.
void QTable::paintEmptyArea ( QPainter * p, int cx, int cy, int
cw, int ch ) [virtual protected]
This function fills the rectangular cx, cy, cw, ch with
the background color. 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
Trolltech AS 13 June 2001 11
QTable(3qt)QTable(3qt)
translated to the cell's origin, while cr specifies the
cell's geometry in contents coordinates.
QPixmap QTable::pixmap ( int row, int col ) const [virtual]
Returns the pixmap set for the cell row, col, or a null-
pixmap if the cell contains no pixmap.
void QTable::pressed ( int row, int col, int button, const QPoint
& mousePos ) [signal]
This signal is emitted whenever the mousebutton button is
pressed above the cell located in row and col. The actual
mouse position is passed as mousePos.
void QTable::removeSelection ( const QTableSelection & s )
[virtual]
Removes the selection matching the values of s from the
table.
void QTable::removeSelection ( int num ) [virtual]
Removes selection number num.
void QTable::resizeData ( int len ) [virtual protected]
This is called when QTable's internal array needs to be
resized.
If you don't use QTableItems you should reimplement this
as an empty method, thus no memory is wasted. In addition,
you will have to reimplement item(), setItem(), and
clearCell() as empty functions in a different way.
As soon as you enable sorting or allow the user to change
rows or columns (see setRowMovingEnabled(),
setColumnMovingEnabled()), you are strongly advised to
reimplement swapColumns(), swapRows(), and swapCells() to
work with your data.
void QTable::resizeEvent ( QResizeEvent * e ) [virtual protected]
Reimplemented for internal reasons; the API is not
affected.
Reimplemented from QWidget.
int QTable::rowAt ( int pos ) const [virtual]
Returns the row which is at pos. pos has to be given in
contents coordinates.
int QTable::rowHeight ( int row ) const [virtual]
Returns the height of the row row.
void QTable::rowHeightChanged ( int row ) [virtual protected
slot]
Call this function whenever the height of row row has
changed in order to rearrange its contents.
Trolltech AS 13 June 2001 12
QTable(3qt)QTable(3qt)void QTable::rowIndexChanged ( int, int, int ) [virtual protected
slot]
This function is called if the order of the rows has been
changed. If you want to change the order programmatically,
call swapRows() or swapColumns().
bool QTable::rowMovingEnabled () const
Returns whether rows can be moved by the user.
int QTable::rowPos ( int row ) const [virtual]
Returns the y-position of the row row in contents
coordinates.
QTableSelection QTable::selection ( int num ) const
Returns selection number num, or an empty QTableSelection
if num is out of range (see QTableSelection::isNull()).
void QTable::selectionChanged () [signal]
Whenever a selection changes, this signal is emitted.
QTable::SelectionMode QTable::selectionMode() const
Reveals the current selection mode.
void QTable::setCellContentFromEditor ( int row, int col )
[virtual protected]
This function is called to set the contents of the cell
row, col from the editor of this cell to this cell. If
there existed already a QTableItem for this cell, this is
removed first (see clearCell()).
If you want to create e.g different QTableItems depending
on the contents of the editor, you might reimplement this
function. Also if you want to work without QTableItems,
you will reimplement this function to set the data which
the user entered to your datastructure.
See also QTableItem::setContentFromEditor().
void QTable::setCellWidget ( int row, int col, QWidget * e )
[virtual]
Sets the widget e to the cell row, col and does all the
placement and further stuff and takes care about correctly
placing are resizing it when the cell geometry changes.
By default widgets are inserted into a vector with
numRows() * numCols() elements. In very big tables you
probably want to store the widgets in a datastructure
which needs less memory (like a hash-table). To make this
possible this functions calls insertWidget() to add the
widget to the internal datastructure. So if you want to
use your own datastructure, reimplement insertWidget(),
cellWidget() and clearCellWidget().
Trolltech AS 13 June 2001 13
QTable(3qt)QTable(3qt)void QTable::setColumnMovingEnabled ( bool b ) [virtual slot]
If b is set to TRUE, columns can be moved by the user.
void QTable::setColumnStretchable ( int col, bool stretch )
[virtual slot]
Sets the column col to stretchable if stretch is TRUE,
else to non-stretchable. So, if the table widgets gets
wider than its contents, stretchable columns are stretched
so that the contents fits exactly into to widget.
void QTable::setColumnWidth ( int col, int w ) [virtual slot]
Resizes the column to w pixel wide.
void QTable::setCurrentCell ( int row, int col ) [virtual slot]
Moves the focus to the cell at position row, col.
See also currentRow() and currentColumn().
void QTable::setItem ( int row, int col, QTableItem * item )
[virtual]
Sets the content for the cell row, col. If cell item
already exists in that position, the old one is deleted.
setItem() also repaints the cell.
void QTable::setLeftMargin ( int m ) [virtual slot]
Sets the left margin to m pixels.
To get rid of the left header entirely, use the following
code:
setLeftMargin( 0 );
verticalHeader()->hide();
void QTable::setNumCols ( int c ) [virtual slot]
Sets the number of columns to c.
void QTable::setNumRows ( int r ) [virtual slot]
Sets the number of rows to r.
void QTable::setPixmap ( int row, int col, const QPixmap & pix )
[virtual]
Sets the pixmap in cell row, col to pix. If no QTableItem
belongs to the cell yet, an item is created.
void QTable::setRowHeight ( int row, int h ) [virtual slot]
Resizes the row to be h pixel height.
void QTable::setRowMovingEnabled ( bool b ) [virtual slot]
If b is set to TRUE, rows can be moved by the user.
void QTable::setRowStretchable ( int row, bool stretch ) [virtual
slot]
Sets the row row to stretchable if stretch is TRUE, else
Trolltech AS 13 June 2001 14
QTable(3qt)QTable(3qt)
to non-stretchable. So, if the table widgets gets higher
than its contents, stretchable rows are stretched so that
the contents fits exactly into to widget.
void QTable::setSelectionMode ( SelectionMode mode )
Sets the table's selection mode to mode. By default multi-
range selections (Multi) are allowed.
void QTable::setShowGrid ( bool b ) [virtual slot]
If b is TRUE, the table grid is shown, otherwise not. The
default is TRUE.
void QTable::setSorting ( bool b ) [virtual slot]
If b is set to TRUE, clicking on the header of a column
sorts this column.
See also sortColumn().
void QTable::setText ( int row, int col, const QString & text )
[virtual]
Sets the text in cell row, col to text. If no QTableItem
belongs to the cell yet, an item is created.
void QTable::setTopMargin ( int m ) [virtual slot]
Sets the top margin to m pixels.
To get rid of the top header entirely, use the following
code:
setTopMargin( 0 );
topHeader()->hide();
void QTable::showColumn ( int col ) [virtual slot]
Shows the column col.
See also hideColumn().
void QTable::showEvent ( QShowEvent * e ) [virtual protected]
Reimplemented for internal reasons; the API is not
affected.
Reimplemented from QWidget.
bool QTable::showGrid () const
Returns whether the table grid shows up or not.
void QTable::showRow ( int row ) [virtual slot]
Shows the row row.
See also hideRow().
QSize QTable::sizeHint () const [virtual]
Reimplemented for internal reasons; the API is not
affected.
Trolltech AS 13 June 2001 15
QTable(3qt)QTable(3qt)
Reimplemented from QWidget.
void QTable::sortColumn ( int col, bool ascending = TRUE, bool
wholeRows = FALSE ) [virtual]
Sorts the column col in ascending order if ascending is
TRUE, else in descending order. If wholeRows is TRUE, for
changing data of the cells swapRows() is called, else
swapCells() is called.
See also swapRows().
bool QTable::sorting () const
Returns wheather clicking on a column header sorts the
column.
See also setSorting().
void QTable::swapCells ( int row1, int col1, int row2, int col2 )
[virtual slot]
Swaps the content of the cells row1, col1 and row2, col2.
This function is used for sorting cells.
void QTable::swapColumns ( int col1, int col2 ) [virtual slot]
Exchanges col1 with col2 and vice versa. This is useful
for sorting, and it allows the user to rearrange the
columns in a different order. If you don't use QTableItems
you will probably reimplement this function.
void QTable::swapRows ( int row1, int row2 ) [virtual slot]
Swaps data of row1 and row2. This is used by sorting
mechanisms or when the user changes the order of the rows.
If you don't use QTableItems you might wish to reimplement
this function.
void QTable::takeItem ( QTableItem * i ) [virtual]
Takes the item i out of the table. This functions doesn't
delete it.
QString QTable::text ( int row, int col ) const [virtual]
Returns the text in cell row, col, or an empty string if
the relevant item does not exist or includes no text.
void QTable::updateCell ( int row, int col )
Repaints the cell at position row, col.
void QTable::valueChanged ( int row, int col ) [signal]
This signal is emitted if the user edited the cell row,
col.
QHeader * QTable::verticalHeader () const
Returns the outer left QHeader.
SEE ALSO
http://doc.trolltech.com/qtable.html
Trolltech AS 13 June 2001 16
QTable(3qt)QTable(3qt)
http://www.trolltech.com/faq/tech.html
COPYRIGHT
Copyright 1992-2001 Trolltech AS,
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
make our job much simpler. Thank you.
In case of content or formattting problems with 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 (2.3.1).
Trolltech AS 13 June 2001 17
