diff options
Diffstat (limited to 'tqtinterface/qt4/src/table/tqtable.cpp')
| -rw-r--r-- | tqtinterface/qt4/src/table/tqtable.cpp | 7375 |
1 files changed, 7375 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/table/tqtable.cpp b/tqtinterface/qt4/src/table/tqtable.cpp new file mode 100644 index 0000000..d87914f --- /dev/null +++ b/tqtinterface/qt4/src/table/tqtable.cpp @@ -0,0 +1,7375 @@ +/**************************************************************************** +** +** Implementation of TQTable widget class +** +** Created : 000607 +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file is part of the table module of the TQt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#include "tqglobal.h" +#if defined(TQ_CC_BOR) +// needed for qsort() because of a std namespace problem on Borland +#include "tqplatformdefs.h" +#endif + +#include "tqtable.h" + +#ifndef TQT_NO_TABLE + +#include <tqpainter.h> +#include <tqlineedit.h> +#include <tqcursor.h> +#include <tqapplication.h> +#include <tqtimer.h> +#include <tqobjectlist.h> +#include <tqiconset.h> +#include <tqcombobox.h> +#include <tqcheckbox.h> +#include <tqdragobject.h> +#include <tqevent.h> +#include <tqlistbox.h> +#include <tqstyle.h> +#include <tqdatatable.h> +#include <tqvalidator.h> + +#include <stdlib.h> +#include <limits.h> + +static bool qt_update_cell_widget = TRUE; +static bool qt_table_clipper_enabled = TRUE; +#ifndef TQT_INTERNAL_TABLE +TQ_EXPORT +#endif +void qt_set_table_clipper_enabled( bool enabled ) +{ + qt_table_clipper_enabled = enabled; +} + +class TQM_EXPORT_TABLE TQTableHeader : public TQHeader +{ + friend class TQTable; + Q_OBJECT + TQ_OBJECT + +public: + enum SectionState { + Normal, + Bold, + Selected + }; + + TQTableHeader( int, TQTable *t, TQWidget* tqparent=0, const char* name=0 ); + ~TQTableHeader() {}; + void addLabel( const TQString &s, int size ); + void setLabel( int section, const TQString & s, int size = -1 ); + void setLabel( int section, const TQIconSet & iconset, const TQString & s, + int size = -1 ); + + void setLabels(const TQStringList & labels); + + void removeLabel( int section ); + + void setSectionState( int s, SectionState state ); + void setSectionStateToAll( SectionState state ); + SectionState sectionState( int s ) const; + + int sectionSize( int section ) const; + int sectionPos( int section ) const; + int sectionAt( int section ) const; + + void setSectionStretchable( int s, bool b ); + bool isSectionStretchable( int s ) const; + + void updateCache(); + +Q_SIGNALS: + void sectionSizeChanged( int s ); + +protected: + void paintEvent( TQPaintEvent *e ); + void paintSection( TQPainter *p, int index, const TQRect& fr ); + void mousePressEvent( TQMouseEvent *e ); + void mouseMoveEvent( TQMouseEvent *e ); + void mouseReleaseEvent( TQMouseEvent *e ); + void mouseDoubleClickEvent( TQMouseEvent *e ); + void resizeEvent( TQResizeEvent *e ); + +private Q_SLOTS: + void doAutoScroll(); + void sectionWidthChanged( int col, int os, int ns ); + void indexChanged( int sec, int oldIdx, int newIdx ); + void updateStretches(); + void updateWidgetStretches(); + +private: + void updateSelections(); + void saveStates(); + void setCaching( bool b ); + void swapSections( int oldIdx, int newIdx, bool swapTable = TRUE ); + bool doSelection( TQMouseEvent *e ); + void sectionLabelChanged( int section ); + void resizeArrays( int n ); + +private: + TQMemArray<int> states, oldStates; + TQMemArray<bool> stretchable; + TQMemArray<int> sectionSizes, sectionPoses; + bool mousePressed; + int pressPos, startPos, endPos; + TQTable *table; + TQTimer *autoScrollTimer; + TQWidget *line1, *line2; + bool caching; + int resizedSection; + bool isResizing; + int numStretches; + TQTimer *stretchTimer, *widgetStretchTimer; + TQTableHeaderPrivate *d; + +}; + +#ifdef _WS_TQWS_ +# define NO_LINE_WIDGET +#endif + + + +struct TQTablePrivate +{ + TQTablePrivate() : hasRowSpan( FALSE ), hasColSpan( FALSE ), + inMenuMode( FALSE ), redirectMouseEvent( FALSE ) + { + hiddenRows.setAutoDelete( TRUE ); + hiddenCols.setAutoDelete( TRUE ); + } + uint hasRowSpan : 1; + uint hasColSpan : 1; + uint inMenuMode : 1; + uint redirectMouseEvent : 1; + TQIntDict<int> hiddenRows, hiddenCols; + TQTimer *geomTimer; + int lastVisRow; + int lastVisCol; +}; + +struct TQTableHeaderPrivate +{ +#ifdef NO_LINE_WIDGET + int oldLinePos; +#endif +}; + +static bool isRowSelection( TQTable::SelectionMode selMode ) +{ + return selMode == TQTable::SingleRow || selMode == TQTable::MultiRow; +} + +/*! + \class TQTableSelection + \brief The TQTableSelection class provides access to a selected area in a + TQTable. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup advanced + \module table + + The selection is a rectangular set of cells in a TQTable. One of + the rectangle's cells is called the anchor cell; this is the cell + that was selected first. The init() function sets the anchor and + the selection rectangle to exactly this cell; the expandTo() + function expands the selection rectangle to include additional + cells. + + There are various access functions to tqfind out about the area: + anchorRow() and anchorCol() return the anchor's position; + leftCol(), rightCol(), topRow() and bottomRow() return the + rectangle's four edges. All four are part of the selection. + + A newly created TQTableSelection is inactive -- isActive() returns + FALSE. You must use init() and expandTo() to activate it. + + \sa TQTable TQTable::addSelection() TQTable::selection() + TQTable::selectCells() TQTable::selectRow() TQTable::selectColumn() +*/ + +/*! + Creates an inactive selection. Use init() and expandTo() to + activate it. +*/ + +TQTableSelection::TQTableSelection() + : active( FALSE ), inited( FALSE ), tRow( -1 ), lCol( -1 ), + bRow( -1 ), rCol( -1 ), aRow( -1 ), aCol( -1 ) +{ +} + +/*! + Creates an active selection, starting at \a start_row and \a + start_col, ending at \a end_row and \a end_col. +*/ + +TQTableSelection::TQTableSelection( int start_row, int start_col, int end_row, int end_col ) + : active( FALSE ), inited( FALSE ), tRow( -1 ), lCol( -1 ), + bRow( -1 ), rCol( -1 ), aRow( -1 ), aCol( -1 ) +{ + init( start_row, start_col ); + expandTo( end_row, end_col ); +} + +/*! + Sets the selection anchor to cell \a row, \a col and the selection + to only contain this cell. The selection is not active until + expandTo() is called. + + To extend the selection to include additional cells, call + expandTo(). + + \sa isActive() +*/ + +void TQTableSelection::init( int row, int col ) +{ + aCol = lCol = rCol = col; + aRow = tRow = bRow = row; + active = FALSE; + inited = TRUE; +} + +/*! + Expands the selection to include cell \a row, \a col. The new + selection rectangle is the bounding rectangle of \a row, \a col + and the previous selection rectangle. After calling this function + the selection is active. + + If you haven't called init(), this function does nothing. + + \sa init() isActive() +*/ + +void TQTableSelection::expandTo( int row, int col ) +{ + if ( !inited ) + return; + active = TRUE; + + if ( row < aRow ) { + tRow = row; + bRow = aRow; + } else { + tRow = aRow; + bRow = row; + } + + if ( col < aCol ) { + lCol = col; + rCol = aCol; + } else { + lCol = aCol; + rCol = col; + } +} + +/*! + Returns TRUE if \a s includes the same cells as the selection; + otherwise returns FALSE. +*/ + +bool TQTableSelection::operator==( const TQTableSelection &s ) const +{ + return ( s.active == active && + s.tRow == tRow && s.bRow == bRow && + s.lCol == lCol && s.rCol == rCol ); +} + +/*! + \fn bool TQTableSelection::operator!=( const TQTableSelection &s ) const + + Returns TRUE if \a s does not include the same cells as the + selection; otherwise returns FALSE. +*/ + + +/*! + \fn int TQTableSelection::topRow() const + + Returns the top row of the selection. + + \sa bottomRow() leftCol() rightCol() +*/ + +/*! + \fn int TQTableSelection::bottomRow() const + + Returns the bottom row of the selection. + + \sa topRow() leftCol() rightCol() +*/ + +/*! + \fn int TQTableSelection::leftCol() const + + Returns the left column of the selection. + + \sa topRow() bottomRow() rightCol() +*/ + +/*! + \fn int TQTableSelection::rightCol() const + + Returns the right column of the selection. + + \sa topRow() bottomRow() leftCol() +*/ + +/*! + \fn int TQTableSelection::anchorRow() const + + Returns the anchor row of the selection. + + \sa anchorCol() expandTo() +*/ + +/*! + \fn int TQTableSelection::anchorCol() const + + Returns the anchor column of the selection. + + \sa anchorRow() expandTo() +*/ + +/*! + \fn int TQTableSelection::numRows() const + + Returns the number of rows in the selection. + + \sa numCols() +*/ +int TQTableSelection::numRows() const +{ + return ( tRow < 0 ) ? 0 : bRow - tRow + 1; +} + +/*! + Returns the number of columns in the selection. + + \sa numRows() +*/ +int TQTableSelection::numCols() const +{ + return ( lCol < 0 ) ? 0 : rCol - lCol + 1; +} + +/*! + \fn bool TQTableSelection::isActive() const + + Returns whether the selection is active or not. A selection is + active after init() \e and expandTo() have been called. +*/ + +/*! + \fn bool TQTableSelection::isEmpty() const + + Returns whether the selection is empty or not. + + \sa numRows(), numCols() +*/ + +/*! + \class TQTableItem + \brief The TQTableItem class provides the cell content for TQTable cells. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup advanced + \module table + + For many applications TQTableItems are ideal for presenting and + editing the contents of TQTable cells. In situations where you need + to create very large tables you may prefer an alternative approach + to using TQTableItems: see the notes on large tables. + + A TQTableItem tqcontains a cell's data, by default, a string and a + pixmap. The table item also holds the cell's display size and how + the data should be aligned. The table item specifies the cell's + \l EditType and the editor used for in-place editing (by default a + TQLineEdit). If you want checkboxes use \l{TQCheckTableItem}, and if + you want comboboxes use \l{TQComboTableItem}. The \l EditType (set + in the constructor) determines whether the cell's contents may be + edited. + + If a pixmap is specified it is displayed to the left of any text. + You can change the text or pixmap with setText() and setPixmap() + respectively. For text you can use setWordWrap(). + + When sorting table items the key() function is used; by default + this returns the table item's text(). Reimplement key() to + customize how your table items will sort. + + Table items are inserted into a table using TQTable::setItem(). If + you insert an item into a cell that already tqcontains a table item + the original item will be deleted. + + Example: + \code + for ( int row = 0; row < table->numRows(); row++ ) { + for ( int col = 0; col < table->numCols(); col++ ) { + table->setItem( row, col, + new TQTableItem( table, TQTableItem::WhenCurrent, TQString::number( row * col ) ) ); + } + } + \endcode + + You can move a table item from one cell to another, in the same or + a different table, using TQTable::takeItem() and TQTable::setItem() + but see also TQTable::swapCells(). + + Table items can be deleted with delete in the standard way; the + table and cell will be updated accordingly. + + Note, that if you have a table item that is not currently in a table + then anything you do to that item other than insert it into a table + will result in undefined behaviour. + + Reimplement createEditor() and setContentFromEditor() if you want + to use your own widget instead of a TQLineEdit for editing cell + contents. Reimplement paint() if you want to display custom + content. + + It is important to ensure that your custom widget can accept the + keyboard focus, so that the user can use the tab key to navigate the + table as normal. Therefore, if the widget returned by createEditor() + does not itself accept the keyboard focus, it is necessary to + nominate a child widget to do so on its behalf. For example, a + TQHBox with two child TQLineEdit widgets may use one of them to + accept the keyboard focus: + + \code + TQWidget* MyTableItem::createEditor() const + { + TQHBox* hbox = new TQHBox( table()->viewport() ); + hbox->setFocusProxy(new TQLineEdit( hbox )); + new TQLineEdit( hbox ); + return hbox; + } + \endcode + + By default, table items may be tqreplaced by new TQTableItems + during the lifetime of a TQTable. Therefore, if you create your + own subclass of TQTableItem, and you want to ensure that + this does not happen, you must call setReplaceable(FALSE) + in the constructor of your subclass. + + \img qtableitems.png Table Items + + \sa TQCheckTableItem TQComboTableItem + +*/ + +/*! + \fn TQTable *TQTableItem::table() const + + Returns the TQTable the table item belongs to. + + \sa TQTable::setItem() TQTableItem() +*/ + +/*! + \enum TQTableItem::EditType + + \target wheneditable + This enum is used to define whether a cell is editable or + read-only (in conjunction with other settings), and how the cell + should be displayed. + + \value Always + The cell always \e looks editable. + + Using this EditType ensures that the editor created with + createEditor() (by default a TQLineEdit) is always visible. This + has implications for the tqalignment of the content: the default + editor aligns everything (even numbers) to the left whilst + numerical values in the cell are by default aligned to the right. + + If a cell with the edit type \c Always looks misaligned you could + reimplement createEditor() for these items. + + \value WhenCurrent + The cell \e looks editable only when it has keyboard focus (see + TQTable::setCurrentCell()). + + \value OnTyping + The cell \e looks editable only when the user types in it or + double-clicks it. It resembles the \c WhenCurrent functionality + but is, perhaps, nicer. + + The \c OnTyping edit type is the default when TQTableItem objects + are created by the convenience functions TQTable::setText() and + TQTable::setPixmap(). + + \value Never The cell is not editable. + + The cell is actually editable only if TQTable::isRowReadOnly() is + FALSE for its row, TQTable::isColumnReadOnly() is FALSE for its + column, and TQTable::isReadOnly() is FALSE. + + TQComboTableItems have an isEditable() property. This property is + used to indicate whether the user may enter their own text or are + restricted to choosing one of the choices in the list. + TQComboTableItems may be interacted with only if they are editable + in accordance with their EditType as described above. + +*/ + +/*! + Creates a table item that is a child of table \a table with no + text. The item has the \l EditType \a et. + + The table item will use a TQLineEdit for its editor, will not + word-wrap and will occupy a single cell. Insert the table item + into a table with TQTable::setItem(). + + The table takes ownership of the table item, so a table item + should not be inserted into more than one table at a time. +*/ + +TQTableItem::TQTableItem( TQTable *table, EditType et ) + : txt(), pix(), t( table ), edType( et ), wordwrap( FALSE ), + tcha( TRUE ), rw( -1 ), cl( -1 ), rowspan( 1 ), colspan( 1 ) +{ + enabled = TRUE; +} + +/*! + Creates a table item that is a child of table \a table with text + \a text. The item has the \l EditType \a et. + + The table item will use a TQLineEdit for its editor, will not + word-wrap and will occupy a single cell. Insert the table item + into a table with TQTable::setItem(). + + The table takes ownership of the table item, so a table item + should not be inserted into more than one table at a time. +*/ + +TQTableItem::TQTableItem( TQTable *table, EditType et, const TQString &text ) + : txt( text ), pix(), t( table ), edType( et ), wordwrap( FALSE ), + tcha( TRUE ), rw( -1 ), cl( -1 ), rowspan( 1 ), colspan( 1 ) +{ + enabled = TRUE; +} + +/*! + Creates a table item that is a child of table \a table with text + \a text and pixmap \a p. The item has the \l EditType \a et. + + The table item will display the pixmap to the left of the text. It + will use a TQLineEdit for editing the text, will not word-wrap and + will occupy a single cell. Insert the table item into a table with + TQTable::setItem(). + + The table takes ownership of the table item, so a table item + should not be inserted in more than one table at a time. +*/ + +TQTableItem::TQTableItem( TQTable *table, EditType et, + const TQString &text, const TQPixmap &p ) + : txt( text ), pix( p ), t( table ), edType( et ), wordwrap( FALSE ), + tcha( TRUE ), rw( -1 ), cl( -1 ), rowspan( 1 ), colspan( 1 ) +{ + enabled = TRUE; +} + +/*! + The destructor deletes this item and frees all allocated + resources. + + If the table item is in a table (i.e. was inserted with + setItem()), it will be removed from the table and the cell it + occupied. +*/ + +TQTableItem::~TQTableItem() +{ + if ( table() ) + table()->takeItem( this ); +} + +int TQTableItem::RTTI = 0; + +/*! + Returns the Run Time Type Identification value for this table item + which for TQTableItems is 0. + + When you create subclasses based on TQTableItem make sure that each + subclass returns a unique rtti() value. It is advisable to use + values greater than 1000, preferably large random numbers, to + allow for extensions to this class. + + \sa TQCheckTableItem::rtti() TQComboTableItem::rtti() +*/ + +int TQTableItem::rtti() const +{ + return RTTI; +} + +/*! + Returns the table item's pixmap or a null pixmap if no pixmap has + been set. + + \sa setPixmap() text() +*/ + +TQPixmap TQTableItem::pixmap() const +{ + return pix; +} + + +/*! + Returns the text of the table item or TQString::null if there is no + text. + + To ensure that the current value of the editor is returned, + setContentFromEditor() is called: + \list 1 + \i if the editMode() is \c Always, or + \i if editMode() is \e not \c Always but the editor of the cell is + active and the editor is not a TQLineEdit. + \endlist + + This means that text() returns the original text value of the item + if the editor is a line edit, until the user commits an edit (e.g. + by pressing Enter or Tab) in which case the new text is returned. + For other editors (e.g. a combobox) setContentFromEditor() is + always called so the currently display value is the one returned. + + \sa setText() pixmap() +*/ + +TQString TQTableItem::text() const +{ + TQWidget *w = table()->cellWidget( rw, cl ); + if ( w && ( edType == Always || + rtti() == TQComboTableItem::RTTI || + rtti() == TQCheckTableItem::RTTI ) ) + ( (TQTableItem*)this )->setContentFromEditor( w ); + return txt; +} + +/*! + Sets pixmap \a p to be this item's pixmap. + + Note that setPixmap() does not update the cell the table item + belongs to. Use TQTable::updateCell() to tqrepaint the cell's + contents. + + For \l{TQComboTableItem}s and \l{TQCheckTableItem}s this function + has no visible effect. + + \sa TQTable::setPixmap() pixmap() setText() +*/ + +void TQTableItem::setPixmap( const TQPixmap &p ) +{ + pix = p; +} + +/*! + Changes the table item's text to \a str. + + Note that setText() does not update the cell the table item + belongs to. Use TQTable::updateCell() to tqrepaint the cell's + contents. + + \sa TQTable::setText() text() setPixmap() TQTable::updateCell() +*/ + +void TQTableItem::setText( const TQString &str ) +{ + txt = str; +} + +/*! + This virtual function is used to paint the contents of an item + using the painter \a p in the rectangular area \a cr using the + color group \a cg. + + If \a selected is TRUE the cell is displayed in a way that + indicates that it is highlighted. + + You don't usually need to use this function but if you want to + draw custom content in a cell you will need to reimplement it. + + The painter passed to this function is translated so that 0, 0 + is the top-left corner of the item that is being painted. + + Note that the painter is not clipped by default in order to get + maximum efficiency. If you want clipping, use + + \code + p->setClipRect( table()->cellRect(row, col), TQPainter::ClipPainter ); + //... your drawing code + p->setClipping( FALSE ); + \endcode + +*/ + +void TQTableItem::paint( TQPainter *p, const TQColorGroup &cg, + const TQRect &cr, bool selected ) +{ + p->fillRect( 0, 0, cr.width(), cr.height(), + selected ? cg.brush( TQColorGroup::Highlight ) + : cg.brush( TQColorGroup::Base ) ); + + int w = cr.width(); + int h = cr.height(); + + int x = 0; + if ( !pix.isNull() ) { + p->drawPixmap( 0, ( cr.height() - pix.height() ) / 2, pix ); + x = pix.width() + 2; + } + + if ( selected ) + p->setPen( cg.highlightedText() ); + else + p->setPen( cg.text() ); + p->drawText( x + 2, 0, w - x - 4, h, + wordwrap ? (tqalignment() | WordBreak) : tqalignment(), text() ); +} + +/*! +This virtual function creates an editor which the user can +interact with to edit the cell's contents. The default +implementation creates a TQLineEdit. + +If the function returns 0, the cell is read-only. + +The returned widget should preferably be invisible, ideally with +TQTable::viewport() as tqparent. + +If you reimplement this function you'll almost certainly need to +reimplement setContentFromEditor(), and may need to reimplement +tqsizeHint(). + +\quotefile table/statistics/statistics.cpp +\skipto createEditor +\printto } + +\sa TQTable::createEditor() setContentFromEditor() TQTable::viewport() setReplaceable() +*/ + +TQWidget *TQTableItem::createEditor() const +{ + TQLineEdit *e = new TQLineEdit( table()->viewport(), "qt_tableeditor" ); + e->setFrame( FALSE ); + e->setText( text() ); + return e; +} + +/*! +Whenever the content of a cell has been edited by the editor \a w, +TQTable calls this virtual function to copy the new values into the +TQTableItem. + +If you reimplement createEditor() and return something that is not +a TQLineEdit you will need to reimplement this function. + +\quotefile table/statistics/statistics.cpp +\skipto setContentFromEditor +\printto } + +\sa TQTable::setCellContentFromEditor() +*/ + +void TQTableItem::setContentFromEditor( TQWidget *w ) +{ + TQLineEdit *le = ::tqqt_cast<TQLineEdit*>(w); + if ( le ) { + TQString input = le->text(); + if ( le->validator() ) + le->validator()->fixup( input ); + setText( input ); + } +} + +/*! + The tqalignment function returns how the text contents of the cell + are aligned when drawn. The default implementation aligns numbers + to the right and any other text to the left. + + \sa TQt::AlignmentFlags +*/ + +// ed: For consistency reasons a tqsetAlignment() should be provided +// as well. + +int TQTableItem::tqalignment() const +{ + bool num; + bool ok1 = FALSE, ok2 = FALSE; + (void)text().toInt( &ok1 ); + if ( !ok1 ) + (void)text().toDouble( &ok2 ); // ### should be .-aligned + num = ok1 || ok2; + + return ( num ? AlignRight : AlignLeft ) | AlignVCenter; +} + +/*! + If \a b is TRUE, the cell's text will be wrapped over multiple + lines, when necessary, to fit the width of the cell; otherwise the + text will be written as a single line. + + \sa wordWrap() TQTable::adjustColumn() TQTable::setColumnStretchable() +*/ + +void TQTableItem::setWordWrap( bool b ) +{ + wordwrap = b; +} + +/*! + Returns TRUE if word wrap is enabled for the cell; otherwise + returns FALSE. + + \sa setWordWrap() +*/ + +bool TQTableItem::wordWrap() const +{ + return wordwrap; +} + +/*! \internal */ + +void TQTableItem::updateEditor( int oldRow, int oldCol ) +{ + if ( edType != Always ) + return; + if ( oldRow != -1 && oldCol != -1 ) + table()->clearCellWidget( oldRow, oldCol ); + if ( rw != -1 && cl != -1 ) + table()->setCellWidget( rw, cl, createEditor() ); +} + +/*! + Returns the table item's edit type. + + This is set when the table item is constructed. + + \sa EditType TQTableItem() +*/ + +TQTableItem::EditType TQTableItem::editType() const +{ + return edType; +} + +/*! + If \a b is TRUE it is acceptable to tqreplace the contents of the + cell with the contents of another TQTableItem. If \a b is FALSE the + contents of the cell may not be tqreplaced by the contents of + another table item. Table items that span more than one cell may + not have their contents tqreplaced by another table item. + + (This differs from \l EditType because EditType is concerned with + whether the \e user is able to change the contents of a cell.) + + \sa isReplaceable() +*/ + +void TQTableItem::setReplaceable( bool b ) +{ + tcha = b; +} + +/*! + This function returns whether the contents of the cell may be + tqreplaced with the contents of another table item. Regardless of + this setting, table items that span more than one cell may not + have their contents tqreplaced by another table item. + + (This differs from \l EditType because EditType is concerned with + whether the \e user is able to change the contents of a cell.) + + \sa setReplaceable() EditType +*/ + +bool TQTableItem::isReplaceable() const +{ + if ( rowspan > 1 || colspan > 1 ) + return FALSE; + return tcha; +} + +/*! + This virtual function returns the key that should be used for + sorting. The default implementation returns the text() of the + relevant item. + + \sa TQTable::setSorting() +*/ + +TQString TQTableItem::key() const +{ + return text(); +} + +/*! + This virtual function returns the size a cell needs to show its + entire content. + + If you subclass TQTableItem you will often need to reimplement this + function. +*/ + +TQSize TQTableItem::tqsizeHint() const +{ + TQSize strutSize = TQApplication::globalStrut(); + if ( edType == Always && table()->cellWidget( rw, cl ) ) + return table()->cellWidget( rw, cl )->tqsizeHint().expandedTo( strutSize ); + + TQSize s; + int x = 0; + if ( !pix.isNull() ) { + s = pix.size(); + s.setWidth( s.width() + 2 ); + x = pix.width() + 2; + } + + TQString t = text(); + if ( !wordwrap && t.tqfind( '\n' ) == -1 ) + return TQSize( s.width() + table()->fontMetrics().width( text() ) + 10, + TQMAX( s.height(), table()->fontMetrics().height() ) ).expandedTo( strutSize ); + + TQRect r = table()->fontMetrics().boundingRect( x + 2, 0, table()->columnWidth( col() ) - x - 4, 0, + wordwrap ? (tqalignment() | WordBreak) : tqalignment(), + text() ); + r.setWidth( TQMAX( r.width() + 10, table()->columnWidth( col() ) ) ); + return TQSize( r.width(), TQMAX( s.height(), r.height() ) ).expandedTo( strutSize ); +} + +/*! + Changes the extent of the TQTableItem so that it spans multiple + cells covering \a rs rows and \a cs columns. The top left cell is + the original cell. + + \warning This function only works if the item has already been + inserted into the table using e.g. TQTable::setItem(). This + function also checks to make sure if \a rs and \a cs are within + the bounds of the table and returns without changing the span if + they are not. In addition swapping, inserting or removing rows and + columns that cross TQTableItems spanning more than one cell is not + supported. + + \sa rowSpan() colSpan() +*/ + +void TQTableItem::setSpan( int rs, int cs ) +{ + if ( rs == rowspan && cs == colspan ) + return; + + if ( !table()->d->hasRowSpan ) + table()->d->hasRowSpan = rs > 1; + if ( !table()->d->hasColSpan ) + table()->d->hasColSpan = cs > 1; + // return if we are thinking too big... + if ( rw + rs > table()->numRows() ) + return; + + if ( cl + cs > table()->numCols() ) + return; + + if ( rw == -1 || cl == -1 ) + return; + + int rrow = rw; + int rcol = cl; + if ( rowspan > 1 || colspan > 1 ) { + TQTable* t = table(); + t->takeItem( this ); + t->setItem( rrow, rcol, this ); + } + + rowspan = rs; + colspan = cs; + + for ( int r = 0; r < rowspan; ++r ) { + for ( int c = 0; c < colspan; ++c ) { + if ( r == 0 && c == 0 ) + continue; + qt_update_cell_widget = FALSE; + table()->setItem( r + rw, c + cl, this ); + qt_update_cell_widget = TRUE; + rw = rrow; + cl = rcol; + } + } + + table()->updateCell( rw, cl ); + TQWidget *w = table()->cellWidget( rw, cl ); + if ( w ) + w->resize( table()->cellGeometry( rw, cl ).size() ); +} + +/*! + Returns the row span of the table item, usually 1. + + \sa setSpan() colSpan() +*/ + +int TQTableItem::rowSpan() const +{ + return rowspan; +} + +/*! + Returns the column span of the table item, usually 1. + + \sa setSpan() rowSpan() +*/ + +int TQTableItem::colSpan() const +{ + return colspan; +} + +/*! + Sets row \a r as the table item's row. Usually you do not need to + call this function. + + If the cell spans multiple rows, this function sets the top row + and retains the height of the multi-cell table item. + + \sa row() setCol() rowSpan() +*/ + +void TQTableItem::setRow( int r ) +{ + rw = r; +} + +/*! + Sets column \a c as the table item's column. Usually you will not + need to call this function. + + If the cell spans multiple columns, this function sets the + left-most column and retains the width of the multi-cell table + item. + + \sa col() setRow() colSpan() +*/ + +void TQTableItem::setCol( int c ) +{ + cl = c; +} + +/*! + Returns the row where the table item is located. If the cell spans + multiple rows, this function returns the top-most row. + + \sa col() setRow() +*/ + +int TQTableItem::row() const +{ + return rw; +} + +/*! + Returns the column where the table item is located. If the cell + spans multiple columns, this function returns the left-most + column. + + \sa row() setCol() +*/ + +int TQTableItem::col() const +{ + return cl; +} + +/*! + If \a b is TRUE, the table item is enabled; if \a b is FALSE the + table item is disabled. + + A disabled item doesn't respond to user interaction. + + \sa isEnabled() +*/ + +void TQTableItem::setEnabled( bool b ) +{ + if ( b == (bool)enabled ) + return; + enabled = b; + table()->updateCell( row(), col() ); +} + +/*! + Returns TRUE if the table item is enabled; otherwise returns FALSE. + + \sa setEnabled() +*/ + +bool TQTableItem::isEnabled() const +{ + return (bool)enabled; +} + +/*! + \class TQComboTableItem + \brief The TQComboTableItem class provides a means of using + comboboxes in TQTables. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup advanced + \module table + + A TQComboTableItem is a table item which looks and behaves like a + combobox. The advantage of using TQComboTableItems rather than real + comboboxes is that a TQComboTableItem uses far less resources than + real comboboxes in \l{TQTable}s. When the cell has the focus it + displays a real combobox which the user can interact with. When + the cell does not have the focus the cell \e looks like a + combobox. Only text items (i.e. no pixmaps) may be used in + TQComboTableItems. + + TQComboTableItem items have the edit type \c WhenCurrent (see + \l{EditType}). The TQComboTableItem's list of items is provided by + a TQStringList passed to the constructor. + + The list of items may be changed using setStringList(). The + current item can be set with setCurrentItem() and retrieved with + currentItem(). The text of the current item can be obtained with + currentText(), and the text of a particular item can be retrieved + with text(). + + If isEditable() is TRUE the TQComboTableItem will permit the user + to either choose an existing list item, or create a new list item + by entering their own text; otherwise the user may only choose one + of the existing list items. + + To populate a table cell with a TQComboTableItem use + TQTable::setItem(). + + TQComboTableItems may be deleted with TQTable::clearCell(). + + TQComboTableItems can be distinguished from \l{TQTableItem}s and + \l{TQCheckTableItem}s using their Run Time Type Identification + number (see rtti()). + + \img qtableitems.png Table Items + + \sa TQCheckTableItem TQTableItem TQComboBox +*/ + +TQComboBox *TQComboTableItem::fakeCombo = 0; +TQWidget *TQComboTableItem::fakeComboWidget = 0; +int TQComboTableItem::fakeRef = 0; + +/*! + Creates a combo table item for the table \a table. The combobox's + list of items is passed in the \a list argument. If \a editable is + TRUE the user may type in new list items; if \a editable is FALSE + the user may only select from the list of items provided. + + By default TQComboTableItems cannot be tqreplaced by other table + items since isReplaceable() returns FALSE by default. + + \sa TQTable::clearCell() EditType +*/ + +TQComboTableItem::TQComboTableItem( TQTable *table, const TQStringList &list, bool editable ) + : TQTableItem( table, WhenCurrent, "" ), entries( list ), current( 0 ), edit( editable ) +{ + setReplaceable( FALSE ); + if ( !TQComboTableItem::fakeCombo ) { + TQComboTableItem::fakeComboWidget = new TQWidget( 0, 0 ); + TQComboTableItem::fakeCombo = new TQComboBox( FALSE, TQComboTableItem::fakeComboWidget, 0 ); + TQComboTableItem::fakeCombo->hide(); + } + ++TQComboTableItem::fakeRef; + if ( entries.count() ) + setText( *entries.at( current ) ); +} + +/*! + TQComboTableItem destructor. +*/ +TQComboTableItem::~TQComboTableItem() +{ + if (--TQComboTableItem::fakeRef <= 0) { + delete TQComboTableItem::fakeComboWidget; + TQComboTableItem::fakeComboWidget = 0; + TQComboTableItem::fakeCombo = 0; + } +} + +/*! + Sets the list items of this TQComboTableItem to the strings in the + string list \a l. +*/ + +void TQComboTableItem::setStringList( const TQStringList &l ) +{ + entries = l; + current = 0; + if ( entries.count() ) + setText( *entries.at( current ) ); + if ( table()->cellWidget( row(), col() ) ) { + cb->clear(); + cb->insertStringList( entries ); + } + table()->updateCell( row(), col() ); +} + +/*! \reimp */ + +TQWidget *TQComboTableItem::createEditor() const +{ + // create an editor - a combobox in our case + ( (TQComboTableItem*)this )->cb = new TQComboBox( edit, table()->viewport(), "qt_editor_cb" ); + cb->insertStringList( entries ); + cb->setCurrentItem( current ); + TQObject::connect( cb, TQT_SIGNAL( activated(int) ), table(), TQT_SLOT( doValueChanged() ) ); + return cb; +} + +/*! \reimp */ + +void TQComboTableItem::setContentFromEditor( TQWidget *w ) +{ + TQComboBox *cb = ::tqqt_cast<TQComboBox*>(w); + if ( cb ) { + entries.clear(); + for ( int i = 0; i < cb->count(); ++i ) + entries << cb->text( i ); + current = cb->currentItem(); + setText( *entries.at( current ) ); + } +} + +/*! \reimp */ + +void TQComboTableItem::paint( TQPainter *p, const TQColorGroup &cg, + const TQRect &cr, bool selected ) +{ + fakeCombo->resize( cr.width(), cr.height() ); + + TQColorGroup c( cg ); + if ( selected ) { + c.setBrush( TQColorGroup::Base, cg.brush( TQColorGroup::Highlight ) ); + c.setColor( TQColorGroup::Text, cg.highlightedText() ); + } + + TQStyle::SFlags flags = TQStyle::Style_Default; + if(isEnabled() && table()->isEnabled()) + flags |= TQStyle::Style_Enabled; + table()->tqstyle().tqdrawComplexControl( TQStyle::CC_ComboBox, p, fakeCombo, fakeCombo->rect(), c, flags ); + + p->save(); + TQRect textR = table()->tqstyle().querySubControlMetrics(TQStyle::CC_ComboBox, fakeCombo, + TQStyle::SC_ComboBoxEditField); + int align = tqalignment(); // tqalignment() changes entries + p->drawText( textR, wordWrap() ? ( align | WordBreak ) : align, *entries.at( current ) ); + p->restore(); +} + +/*! + Sets the list item \a i to be the combo table item's current list + item. + + \sa currentItem() +*/ + +void TQComboTableItem::setCurrentItem( int i ) +{ + TQWidget *w = table()->cellWidget( row(), col() ); + TQComboBox *cb = ::tqqt_cast<TQComboBox*>(w); + if ( cb ) { + cb->setCurrentItem( i ); + current = i; + setText( cb->currentText() ); + } else { + current = i; + setText( *entries.at( i ) ); + table()->updateCell( row(), col() ); + } +} + +/*! + \overload + + Sets the list item whose text is \a s to be the combo table item's + current list item. Does nothing if no list item has the text \a s. + + \sa currentItem() +*/ + +void TQComboTableItem::setCurrentItem( const TQString &s ) +{ + int i = entries.tqfindIndex( s ); + if ( i != -1 ) + setCurrentItem( i ); +} + +/*! + Returns the index of the combo table item's current list item. + + \sa setCurrentItem() +*/ + +int TQComboTableItem::currentItem() const +{ + TQWidget *w = table()->cellWidget( row(), col() ); + TQComboBox *cb = ::tqqt_cast<TQComboBox*>(w); + if ( cb ) + return cb->currentItem(); + return current; +} + +/*! + Returns the text of the combo table item's current list item. + + \sa currentItem() text() +*/ + +TQString TQComboTableItem::currentText() const +{ + TQWidget *w = table()->cellWidget( row(), col() ); + TQComboBox *cb = ::tqqt_cast<TQComboBox*>(w); + if ( cb ) + return cb->currentText(); + return *entries.at( current ); +} + +/*! + Returns the total number of list items in the combo table item. +*/ + +int TQComboTableItem::count() const +{ + TQWidget *w = table()->cellWidget( row(), col() ); + TQComboBox *cb = ::tqqt_cast<TQComboBox*>(w); + if ( cb ) + return cb->count(); + return (int)entries.count(); //### size_t/int cast +} + +/*! + Returns the text of the combo's list item at index \a i. + + \sa currentText() +*/ + +TQString TQComboTableItem::text( int i ) const +{ + TQWidget *w = table()->cellWidget( row(), col() ); + TQComboBox *cb = ::tqqt_cast<TQComboBox*>(w); + if ( cb ) + return cb->text( i ); + return *entries.at( i ); +} + +/*! + If \a b is TRUE the combo table item can be edited, i.e. the user + may enter a new text item themselves. If \a b is FALSE the user may + may only choose one of the existing items. + + \sa isEditable() +*/ + +void TQComboTableItem::setEditable( bool b ) +{ + edit = b; +} + +/*! + Returns TRUE if the user can add their own list items to the + combobox's list of items; otherwise returns FALSE. + + \sa setEditable() +*/ + +bool TQComboTableItem::isEditable() const +{ + return edit; +} + +int TQComboTableItem::RTTI = 1; + +/*! + \fn int TQComboTableItem::rtti() const + + Returns 1. + + Make your derived classes return their own values for rtti()to + distinguish between different table item subclasses. You should + use values greater than 1000, preferably a large random number, to + allow for extensions to this class. + + + \sa TQTableItem::rtti() +*/ + +int TQComboTableItem::rtti() const +{ + return RTTI; +} + +/*! \reimp */ + +TQSize TQComboTableItem::tqsizeHint() const +{ + fakeCombo->insertItem( currentText() ); + fakeCombo->setCurrentItem( fakeCombo->count() - 1 ); + TQSize sh = fakeCombo->tqsizeHint(); + fakeCombo->removeItem( fakeCombo->count() - 1 ); + return sh.expandedTo( TQApplication::globalStrut() ); +} + +/*! + \class TQCheckTableItem + \brief The TQCheckTableItem class provides checkboxes in TQTables. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup advanced + \module table + + A TQCheckTableItem is a table item which looks and behaves like a + checkbox. The advantage of using TQCheckTableItems rather than real + checkboxes is that a TQCheckTableItem uses far less resources than + a real checkbox would in a \l{TQTable}. When the cell has the focus + it displays a real checkbox which the user can interact with. When + the cell does not have the focus the cell \e looks like a + checkbox. Pixmaps may not be used in TQCheckTableItems. + + TQCheckTableItem items have the edit type \c WhenCurrent (see + \l{EditType}). + + To change the checkbox's label use setText(). The checkbox can be + checked and unchecked with setChecked() and its state retrieved + using isChecked(). + + To populate a table cell with a TQCheckTableItem use + TQTable::setItem(). + + TQCheckTableItems can be distinguished from \l{TQTableItem}s and + \l{TQComboTableItem}s using their Run Time Type Identification + (rtti) value. + + \img qtableitems.png Table Items + + \sa rtti() EditType TQComboTableItem TQTableItem TQCheckBox +*/ + +/*! + Creates a TQCheckTableItem with an \l{EditType} of \c WhenCurrent + as a child of \a table. The checkbox is initially unchecked and + its label is set to the string \a txt. +*/ + +TQCheckTableItem::TQCheckTableItem( TQTable *table, const TQString &txt ) + : TQTableItem( table, WhenCurrent, txt ), checked( FALSE ) +{ +} + +/*! \reimp */ + +void TQCheckTableItem::setText( const TQString &t ) +{ + TQTableItem::setText( t ); + TQWidget *w = table()->cellWidget( row(), col() ); + TQCheckBox *cb = ::tqqt_cast<TQCheckBox*>(w); + if ( cb ) + cb->setText( t ); +} + + +/*! \reimp */ + +TQWidget *TQCheckTableItem::createEditor() const +{ + // create an editor - a combobox in our case + ( (TQCheckTableItem*)this )->cb = new TQCheckBox( table()->viewport(), "qt_editor_checkbox" ); + cb->setChecked( checked ); + cb->setText( text() ); + cb->setBackgroundColor( table()->viewport()->backgroundColor() ); + TQObject::connect( cb, TQT_SIGNAL( toggled(bool) ), table(), TQT_SLOT( doValueChanged() ) ); + return cb; +} + +/*! \reimp */ + +void TQCheckTableItem::setContentFromEditor( TQWidget *w ) +{ + TQCheckBox *cb = ::tqqt_cast<TQCheckBox*>(w); + if ( cb ) + checked = cb->isChecked(); +} + +/*! \reimp */ + +void TQCheckTableItem::paint( TQPainter *p, const TQColorGroup &cg, + const TQRect &cr, bool selected ) +{ + p->fillRect( 0, 0, cr.width(), cr.height(), + selected ? cg.brush( TQColorGroup::Highlight ) + : cg.brush( TQColorGroup::Base ) ); + + int w = cr.width(); + int h = cr.height(); + TQSize sz = TQSize( table()->tqstyle().tqpixelMetric( TQStyle::PM_IndicatorWidth ), + table()->tqstyle().tqpixelMetric( TQStyle::PM_IndicatorHeight ) ); + TQColorGroup c( cg ); + c.setBrush( TQColorGroup::Background, c.brush( TQColorGroup::Base ) ); + TQStyle::SFlags flags = TQStyle::Style_Default; + if(isEnabled()) + flags |= TQStyle::Style_Enabled; + if ( checked ) + flags |= TQStyle::Style_On; + else + flags |= TQStyle::Style_Off; + if ( isEnabled() && table()->isEnabled() ) + flags |= TQStyle::Style_Enabled; + + table()->tqstyle().tqdrawPrimitive( TQStyle::PE_Indicator, p, + TQRect( 0, ( cr.height() - sz.height() ) / 2, sz.width(), sz.height() ), c, flags ); + int x = sz.width() + 6; + w = w - x; + if ( selected ) + p->setPen( cg.highlightedText() ); + else + p->setPen( cg.text() ); + p->drawText( x, 0, w, h, wordWrap() ? ( tqalignment() | WordBreak ) : tqalignment(), text() ); +} + +/*! + If \a b is TRUE the checkbox is checked; if \a b is FALSE the + checkbox is unchecked. + + \sa isChecked() +*/ + +void TQCheckTableItem::setChecked( bool b ) +{ + checked = b; + table()->updateCell( row(), col() ); + TQWidget *w = table()->cellWidget( row(), col() ); + TQCheckBox *cb = ::tqqt_cast<TQCheckBox*>(w); + if ( cb ) + cb->setChecked( b ); +} + +/*! + Returns TRUE if the checkbox table item is checked; otherwise + returns FALSE. + + \sa setChecked() +*/ + +bool TQCheckTableItem::isChecked() const +{ + // #### why was this next line here. It must not be here, as + // #### people want to call isChecked() from within paintCell() + // #### and end up in an infinite loop that way + // table()->updateCell( row(), col() ); + TQWidget *w = table()->cellWidget( row(), col() ); + TQCheckBox *cb = ::tqqt_cast<TQCheckBox*>(w); + if ( cb ) + return cb->isChecked(); + return checked; +} + +int TQCheckTableItem::RTTI = 2; + +/*! + \fn int TQCheckTableItem::rtti() const + + Returns 2. + + Make your derived classes return their own values for rtti()to + distinguish between different table item subclasses. You should + use values greater than 1000, preferably a large random number, to + allow for extensions to this class. + + \sa TQTableItem::rtti() +*/ + +int TQCheckTableItem::rtti() const +{ + return RTTI; +} + +/*! \reimp */ + +TQSize TQCheckTableItem::tqsizeHint() const +{ + TQSize sz = TQSize( table()->tqstyle().tqpixelMetric( TQStyle::PM_IndicatorWidth ), + table()->tqstyle().tqpixelMetric( TQStyle::PM_IndicatorHeight ) ); + sz.setWidth( sz.width() + 6 ); + TQSize sh( TQTableItem::tqsizeHint() ); + return TQSize( sh.width() + sz.width(), TQMAX( sh.height(), sz.height() ) ). + expandedTo( TQApplication::globalStrut() ); +} + +/*! \file table/small-table-demo/main.cpp */ +/*! \file table/bigtable/main.cpp */ +/*! \file table/statistics/statistics.cpp */ + +/*! + \class TQTable + \brief The TQTable class provides a flexible editable table widget. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \mainclass + \ingroup advanced + \module table + + TQTable is easy to use, although it does have a large API because + of the comprehensive functionality that it provides. TQTable + includes functions for manipulating \link #headers + headers\endlink, \link #columnsrows rows and columns\endlink, + \link #cells cells\endlink and \link #selections + selections\endlink. TQTable also provides in-place editing and + \link dnd.html drag and drop\endlink, as well as a useful set of + \link #Q_SIGNALS Q_SIGNALS\endlink. TQTable efficiently supports very + large tables, for example, tables one million by one million cells + are perfectly possible. TQTable is economical with memory, using + none for unused cells. + + \code + TQTable *table = new TQTable( 100, 250, this ); + table->setPixmap( 3, 2, pix ); + table->setText( 3, 2, "A pixmap" ); + \endcode + + The first line constructs the table specifying its size in rows + and columns. We then insert a pixmap and some text into the \e + same \link #cells cell\endlink, with the pixmap appearing to the + left of the text. TQTable cells can be populated with + \l{TQTableItem}s, \l{TQComboTableItem}s or by \l{TQCheckTableItem}s. + 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 TQTable begin at 0.) + + If you want to use mouse tracking call setMouseTracking( TRUE ) on + the \e viewport; (see \link tqscrollview.html#allviews + TQScrollView\endlink). + + \img qtableitems.png Table Items + + \target headers + \section1 Headers + + TQTable 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 TQHeader::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 TQHeader regarding section numbers is overriden + for TQTable. See the explanation below in the Rows and Columns + section in the discussion of moving columns and rows. + + \target columnsrows + \section1 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 TQHeader + section numbers is overridden by TQTable. Currently in TQTable, 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 TQHeader. + The TQTable TQHeader 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 \link + qtableitem.html#wheneditable TQTableItem::EditType\endlink.) + + The row and column which have the focus are returned by + currentRow() and currentColumn() respectively. + + Although many TQTable functions operate in terms of rows and + columns the indexOf() function returns a single integer + identifying a particular cell. + + \target cells + \section1 Cells + + All of a TQTable'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 TQTableItems or TQTableItem + subclasses. The second approach doesn't use TQTableItems 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 TQTableItem 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 TQLineEdit. A pixmap may be put in a cell with setPixmap(), + which also creates a table item if required. A cell may contain \e + both a pixmap and text; the pixmap is displayed to the left of the + text. Another approach is to construct a TQTableItem or TQTableItem + subclass, set its properties, then insert it into a cell with + setItem(). + + If you want cells which contain comboboxes use the TQComboTableItem + class. Similarly if you require cells containing checkboxes use + the TQCheckTableItem class. These table items look and behave just + like the combobox or checkbox widgets but consume far less memory. + + \quotefile table/small-table-demo/main.cpp + \skipto int j + \printuntil TQCheckTableItem + In the example above we create a column of TQCheckTableItems and + insert them into the table using setItem(). + + TQTable takes ownership of its TQTableItems 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 TQTableItems, and the values in + TQComboTableItems and TQCheckTableItems works automatically. Cells + may be editable or read-only, see \link + qtableitem.html#wheneditable TQTableItem::EditType\endlink. If you + want fine control over editing see beginEdit() and endEdit(). + + The contents of a cell can be retrieved as a TQTableItem 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 tqrepaint 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 TQTableItem might be a simpler + approach. The cell's widget (if there is one) can be removed with + clearCellWidget(). + + \keyword notes on large tables + \target bigtables + \section2 Large tables + + For large, sparse, tables using TQTableItems or other widgets is + inefficient. The solution is to \e 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 TQTable 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 TQTableItems and + TQWidgets, 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 \l table/bigtable/main.cpp example.) + + For more information on cells see the TQTableItem documenation. + + \target selections + \section1 Selections + + TQTable'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. + + TQTable'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 TQTableSelection objects. + + To easily add a new selection use selectCells(), selectRow() or + selectColumn(). + + Alternatively, use addSelection() to add new selections using + TQTableSelection objects. The advantage of using TQTableSelection + objects is that you can call TQTableSelection::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(). + + \target Q_SIGNALS + \section1 Signals + + When the user clicks a cell the currentChanged() signal is + emitted. You can also connect to the lower level clicked(), + doubleClicked() and pressed() Q_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. +*/ + +/*! + \fn void TQTable::currentChanged( int row, int col ) + + This signal is emitted when the current cell has changed to \a + row, \a col. +*/ + +/*! + \fn void TQTable::valueChanged( int row, int col ) + + This signal is emitted when the user changed the value in the cell + at \a row, \a col. +*/ + +/*! + \fn int TQTable::currentRow() const + + Returns the current row. + + \sa currentColumn() +*/ + +/*! + \fn int TQTable::currentColumn() const + + Returns the current column. + + \sa currentRow() +*/ + +/*! + \enum TQTable::EditMode + + \value NotEditing No cell is currently being edited. + + \value Editing A cell is currently being edited. The editor was + initialised with the cell's contents. + + \value Replacing A cell is currently being edited. The editor was + not initialised with the cell's contents. +*/ + +/*! + \enum TQTable::SelectionMode + + \value NoSelection No cell can be selected by the user. + + \value Single The user may only select a single range of cells. + + \value Multi The user may select multiple ranges of cells. + + \value SingleRow The user may select one row at once. + + \value MultiRow The user may select multiple rows. +*/ + +/*! + \enum TQTable::FocusStyle + + Specifies how the current cell (focus cell) is drawn. + + \value 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 + + \value 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. + +*/ + +/*! + \fn void TQTable::clicked( int row, int col, int button, const TQPoint &mousePos ) + + This signal is emitted when mouse button \a button is clicked. The + cell where the event took place is at \a row, \a col, and the + mouse's position is in \a mousePos. + + \sa TQt::ButtonState +*/ + +/*! + \fn void TQTable::doubleClicked( int row, int col, int button, const TQPoint &mousePos ) + + This signal is emitted when mouse button \a button is + double-clicked. The cell where the event took place is at \a row, + \a col, and the mouse's position is in \a mousePos. + + \sa TQt::ButtonState +*/ + +/*! + \fn void TQTable::pressed( int row, int col, int button, const TQPoint &mousePos ) + + This signal is emitted when mouse button \a button is pressed. The + cell where the event took place is at \a row, \a col, and the + mouse's position is in \a mousePos. + + \sa TQt::ButtonState +*/ + +/*! + \fn void TQTable::selectionChanged() + + This signal is emitted whenever a selection changes. + + \sa TQTableSelection +*/ + +/*! + \fn void TQTable::contextMenuRequested( int row, int col, const TQPoint & pos ) + + 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 \a row, \a col. \a 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. +*/ + +/*! + Creates an empty table object called \a name as a child of \a + tqparent. + + Call setNumRows() and setNumCols() to set the table size before + populating the table if you're using TQTableItems. + + \sa TQWidget::clearWFlags() TQt::WidgetFlags +*/ + +TQTable::TQTable( TQWidget *tqparent, const char *name ) + : TQScrollView( tqparent, name, (WFlags)(WNoAutoErase | TQt::WStaticContents) ), + leftHeader( 0 ), topHeader( 0 ), + currentSel( 0 ), lastSortCol( -1 ), sGrid( TRUE ), mRows( FALSE ), mCols( FALSE ), + asc( TRUE ), doSort( TRUE ), readOnly( FALSE ) +{ + init( 0, 0 ); +} + +/*! + Constructs an empty table called \a name with \a numRows rows and + \a numCols columns. The table is a child of \a tqparent. + + If you're using \l{TQTableItem}s to populate the table's cells, you + can create TQTableItem, TQComboTableItem and TQCheckTableItem items + and insert them into the table using setItem(). (See the notes on + large tables for an alternative to using TQTableItems.) + + \sa TQWidget::clearWFlags() TQt::WidgetFlags +*/ + +TQTable::TQTable( int numRows, int numCols, TQWidget *tqparent, const char *name ) + : TQScrollView( tqparent, name, (WFlags)(WNoAutoErase | TQt::WStaticContents) ), + leftHeader( 0 ), topHeader( 0 ), + currentSel( 0 ), lastSortCol( -1 ), sGrid( TRUE ), mRows( FALSE ), mCols( FALSE ), + asc( TRUE ), doSort( TRUE ), readOnly( FALSE ) +{ + init( numRows, numCols ); +} + +/*! \internal +*/ + +void TQTable::init( int rows, int cols ) +{ +#ifndef TQT_NO_DRAGANDDROP + setDragAutoScroll( FALSE ); +#endif + d = new TQTablePrivate; + d->geomTimer = new TQTimer( this ); + d->lastVisCol = 0; + d->lastVisRow = 0; + connect( d->geomTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( updateGeometriesSlot() ) ); + shouldClearSelection = FALSE; + dEnabled = FALSE; + roRows.setAutoDelete( TRUE ); + roCols.setAutoDelete( TRUE ); + setSorting( FALSE ); + + unused = TRUE; // It's unused, ain't it? :) + + selMode = Multi; + + contents.setAutoDelete( TRUE ); + widgets.setAutoDelete( TRUE ); + + // Enable clipper and set background mode + enableClipper( qt_table_clipper_enabled ); + + viewport()->setFocusProxy( this ); + viewport()->setFocusPolicy( Qt::WheelFocus ); + + viewport()->setBackgroundMode( TQt::PaletteBase ); + setBackgroundMode( TQt::PaletteBackground, TQt::PaletteBase ); + setResizePolicy( Manual ); + selections.setAutoDelete( TRUE ); + + // Create headers + leftHeader = new TQTableHeader( rows, this, this, "left table header" ); + leftHeader->setOrientation( Qt::Vertical ); + leftHeader->setTracking( TRUE ); + leftHeader->setMovingEnabled( TRUE ); + topHeader = new TQTableHeader( cols, this, this, "right table header" ); + topHeader->setOrientation( Qt::Horizontal ); + topHeader->setTracking( TRUE ); + topHeader->setMovingEnabled( TRUE ); + if ( TQApplication::reverseLayout() ) + setMargins( 0, fontMetrics().height() + 4, 30, 0 ); + else + setMargins( 30, fontMetrics().height() + 4, 0, 0 ); + + topHeader->setUpdatesEnabled( FALSE ); + leftHeader->setUpdatesEnabled( FALSE ); + // Initialize headers + int i = 0; + for ( i = 0; i < numCols(); ++i ) + topHeader->resizeSection( i, TQMAX( 100, TQApplication::globalStrut().height() ) ); + for ( i = 0; i < numRows(); ++i ) + leftHeader->resizeSection( i, TQMAX( 20, TQApplication::globalStrut().width() ) ); + topHeader->setUpdatesEnabled( TRUE ); + leftHeader->setUpdatesEnabled( TRUE ); + + // Prepare for contents + contents.setAutoDelete( FALSE ); + + // Connect header, table and scrollbars + connect( horizontalScrollBar(), TQT_SIGNAL( valueChanged(int) ), + topHeader, TQT_SLOT( setOffset(int) ) ); + connect( verticalScrollBar(), TQT_SIGNAL( valueChanged(int) ), + leftHeader, TQT_SLOT( setOffset(int) ) ); + connect( topHeader, TQT_SIGNAL( sectionSizeChanged(int) ), + this, TQT_SLOT( columnWidthChanged(int) ) ); + connect( topHeader, TQT_SIGNAL( indexChange(int,int,int) ), + this, TQT_SLOT( columnIndexChanged(int,int,int) ) ); + connect( topHeader, TQT_SIGNAL( sectionClicked(int) ), + this, TQT_SLOT( columnClicked(int) ) ); + connect( leftHeader, TQT_SIGNAL( sectionSizeChanged(int) ), + this, TQT_SLOT( rowHeightChanged(int) ) ); + connect( leftHeader, TQT_SIGNAL( indexChange(int,int,int) ), + this, TQT_SLOT( rowIndexChanged(int,int,int) ) ); + + // Initialize variables + autoScrollTimer = new TQTimer( this ); + connect( autoScrollTimer, TQT_SIGNAL( timeout() ), + this, TQT_SLOT( doAutoScroll() ) ); + curRow = curCol = 0; + topHeader->setSectionState( curCol, TQTableHeader::Bold ); + leftHeader->setSectionState( curRow, TQTableHeader::Bold ); + edMode = NotEditing; + editRow = editCol = -1; + + drawActiveSelection = TRUE; + + installEventFilter( this ); + + focusStl = SpreadSheet; + + was_visible = FALSE; + + // initial size + resize( 640, 480 ); +} + +/*! + Releases all the resources used by the TQTable object, + including all \l{TQTableItem}s and their widgets. +*/ + +TQTable::~TQTable() +{ + setUpdatesEnabled( FALSE ); + contents.setAutoDelete( TRUE ); + contents.clear(); + widgets.clear(); + + delete d; +} + +void TQTable::setReadOnly( bool b ) +{ + readOnly = b; + + TQTableItem *i = item(curRow, curCol); + if (readOnly && isEditing()) { + endEdit(editRow, editCol, TRUE, FALSE); + } else if (!readOnly && i && (i->editType() == TQTableItem::WhenCurrent + || i->editType() == TQTableItem::Always)) { + editCell(curRow, curCol); + } +} + +/*! + If \a ro is TRUE, row \a 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 \link qtableitem.html#wheneditable TQTableItem::EditType\endlink. + + \sa isRowReadOnly() setColumnReadOnly() setReadOnly() +*/ + +void TQTable::setRowReadOnly( int row, bool ro ) +{ + if ( ro ) + roRows.tqreplace( row, new int( 0 ) ); + else + roRows.remove( row ); + + if (curRow == row) { + TQTableItem *i = item(curRow, curCol); + if (ro && isEditing()) { + endEdit(editRow, editCol, TRUE, FALSE); + } else if (!ro && i && (i->editType() == TQTableItem::WhenCurrent + || i->editType() == TQTableItem::Always)) { + editCell(curRow, curCol); + } + } +} + +/*! + If \a ro is TRUE, column \a 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 \link qtableitem.html#wheneditable TQTableItem::EditType\endlink. + + \sa isColumnReadOnly() setRowReadOnly() setReadOnly() + +*/ + +void TQTable::setColumnReadOnly( int col, bool ro ) +{ + if ( ro ) + roCols.tqreplace( col, new int( 0 ) ); + else + roCols.remove( col ); + + if (curCol == col) { + TQTableItem *i = item(curRow, curCol); + if (ro && isEditing()) { + endEdit(editRow, editCol, TRUE, FALSE); + } else if (!ro && i && (i->editType() == TQTableItem::WhenCurrent + || i->editType() == TQTableItem::Always)) { + editCell(curRow, curCol); + } + } +} + +/*! + \property TQTable::readOnly + \brief whether the table is read-only + + Whether a cell in the table is editable or read-only depends on + the cell's \link TQTableItem::EditType EditType\endlink, and this setting: + see \link qtableitem.html#wheneditable + TQTableItem::EditType\endlink. + + \sa TQWidget::enabled setColumnReadOnly() setRowReadOnly() +*/ + +bool TQTable::isReadOnly() const +{ + return readOnly; +} + +/*! + Returns TRUE if row \a row is read-only; otherwise returns FALSE. + + Whether a cell in this row is editable or read-only depends on the + cell's \link TQTableItem::EditType EditType\endlink, and this + setting: see \link qtableitem.html#wheneditable + TQTableItem::EditType\endlink. + + \sa setRowReadOnly() isColumnReadOnly() +*/ + +bool TQTable::isRowReadOnly( int row ) const +{ + return (roRows.tqfind( row ) != 0); +} + +/*! + Returns TRUE if column \a 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 \link + qtableitem.html#wheneditable TQTableItem::EditType\endlink. + + \sa setColumnReadOnly() isRowReadOnly() +*/ + +bool TQTable::isColumnReadOnly( int col ) const +{ + return (roCols.tqfind( col ) != 0); +} + +void TQTable::setSelectionMode( SelectionMode mode ) +{ + if ( mode == selMode ) + return; + selMode = mode; + clearSelection(); + if ( isRowSelection( selMode ) && numRows() > 0 && numCols() > 0 ) { + currentSel = new TQTableSelection(); + selections.append( currentSel ); + currentSel->init( curRow, 0 ); + currentSel->expandTo( curRow, numCols() - 1 ); + repaintSelections( 0, currentSel ); + } +} + +/*! + \property TQTable::selectionMode + \brief the current selection mode + + The default mode is \c Multi which allows the user to select + multiple ranges of cells. + + \sa SelectionMode setSelectionMode() +*/ + +TQTable::SelectionMode TQTable::selectionMode() const +{ + return selMode; +} + +/*! + \property TQTable::focusStyle + \brief how the current (focus) cell is drawn + + The default style is \c SpreadSheet. + + \sa TQTable::FocusStyle +*/ + +void TQTable::setFocusStyle( FocusStyle fs ) +{ + focusStl = fs; + updateCell( curRow, curCol ); +} + +TQTable::FocusStyle TQTable::focusStyle() const +{ + return focusStl; +} + +/*! + 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 TQTable::updateHeaderStates() +{ + horizontalHeader()->setUpdatesEnabled( FALSE ); + verticalHeader()->setUpdatesEnabled( FALSE ); + + ( (TQTableHeader*)verticalHeader() )->setSectionStateToAll( TQTableHeader::Normal ); + ( (TQTableHeader*)horizontalHeader() )->setSectionStateToAll( TQTableHeader::Normal ); + + TQPtrListIterator<TQTableSelection> it( selections ); + TQTableSelection *s; + while ( ( s = it.current() ) != 0 ) { + ++it; + if ( s->isActive() ) { + if ( s->leftCol() == 0 && + s->rightCol() == numCols() - 1 ) { + for ( int i = 0; i < s->bottomRow() - s->topRow() + 1; ++i ) + leftHeader->setSectionState( s->topRow() + i, TQTableHeader::Selected ); + } + if ( s->topRow() == 0 && + s->bottomRow() == numRows() - 1 ) { + for ( int i = 0; i < s->rightCol() - s->leftCol() + 1; ++i ) + topHeader->setSectionState( s->leftCol() + i, TQTableHeader::Selected ); + } + } + } + + horizontalHeader()->setUpdatesEnabled( TRUE ); + verticalHeader()->setUpdatesEnabled( TRUE ); + horizontalHeader()->tqrepaint( FALSE ); + verticalHeader()->tqrepaint( FALSE ); +} + +/*! + Returns the table's top TQHeader. + + This header tqcontains the column labels. + + To modify a column label use TQHeader::setLabel(), e.g. + \quotefile table/statistics/statistics.cpp + \skipto horizontalHeader + \printline + + \sa verticalHeader() setTopMargin() TQHeader +*/ + +TQHeader *TQTable::horizontalHeader() const +{ + return (TQHeader*)topHeader; +} + +/*! + Returns the table's vertical TQHeader. + + This header tqcontains the row labels. + + \sa horizontalHeader() setLeftMargin() TQHeader +*/ + +TQHeader *TQTable::verticalHeader() const +{ + return (TQHeader*)leftHeader; +} + +void TQTable::setShowGrid( bool b ) +{ + if ( sGrid == b ) + return; + sGrid = b; + updateContents(); +} + +/*! + \property TQTable::showGrid + \brief whether the table's grid is displayed + + The grid is shown by default. +*/ + +bool TQTable::showGrid() const +{ + return sGrid; +} + +/*! + \property TQTable::columnMovingEnabled + \brief 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 TQTable is used to move header sections as a result of user + interaction, the mapping between header indexes and section exposed by + TQHeader will not reflect the order of the headers in the table; i.e., + TQTable does not call TQHeader::moveSection() to move sections but handles + move operations internally. + + \sa rowMovingEnabled +*/ + +void TQTable::setColumnMovingEnabled( bool b ) +{ + mCols = b; +} + +bool TQTable::columnMovingEnabled() const +{ + return mCols; +} + +/*! + \property TQTable::rowMovingEnabled + \brief 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 TQTable is used to move header sections as a result of user + interaction, the mapping between header indexes and section exposed by + TQHeader will not reflect the order of the headers in the table; i.e., + TQTable does not call TQHeader::moveSection() to move sections but handles + move operations internally. + + \sa columnMovingEnabled +*/ + +void TQTable::setRowMovingEnabled( bool b ) +{ + mRows = b; +} + +bool TQTable::rowMovingEnabled() const +{ + return mRows; +} + +/*! + This is called when TQTable's internal array needs to be resized to + \a len elements. + + If you don't use TQTableItems you should reimplement this as an + empty method to avoid wasting memory. See the notes on large + tables for further details. +*/ + +void TQTable::resizeData( int len ) +{ + contents.resize( len ); + widgets.resize( len ); +} + +/*! + Swaps the data in \a row1 and \a 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 \l{TQTableItem}s 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 \a swapHeader is TRUE, the rows' header contents is also + swapped. + + This function will not update the TQTable, you will have to do + this manually, e.g. by calling updateContents(). + + \sa swapColumns() swapCells() +*/ + +void TQTable::swapRows( int row1, int row2, bool swapHeader ) +{ + if ( swapHeader ) + leftHeader->swapSections( row1, row2, FALSE ); + + TQPtrVector<TQTableItem> tmpContents; + tmpContents.resize( numCols() ); + TQPtrVector<TQWidget> tmpWidgets; + tmpWidgets.resize( numCols() ); + int i; + + contents.setAutoDelete( FALSE ); + widgets.setAutoDelete( FALSE ); + for ( i = 0; i < numCols(); ++i ) { + TQTableItem *i1, *i2; + i1 = item( row1, i ); + i2 = item( row2, i ); + if ( i1 || i2 ) { + tmpContents.insert( i, i1 ); + contents.remove( indexOf( row1, i ) ); + contents.insert( indexOf( row1, i ), i2 ); + contents.remove( indexOf( row2, i ) ); + contents.insert( indexOf( row2, i ), tmpContents[ i ] ); + if ( contents[ indexOf( row1, i ) ] ) + contents[ indexOf( row1, i ) ]->setRow( row1 ); + if ( contents[ indexOf( row2, i ) ] ) + contents[ indexOf( row2, i ) ]->setRow( row2 ); + } + + TQWidget *w1, *w2; + w1 = cellWidget( row1, i ); + w2 = cellWidget( row2, i ); + if ( w1 || w2 ) { + tmpWidgets.insert( i, w1 ); + widgets.remove( indexOf( row1, i ) ); + widgets.insert( indexOf( row1, i ), w2 ); + widgets.remove( indexOf( row2, i ) ); + widgets.insert( indexOf( row2, i ), tmpWidgets[ i ] ); + } + } + contents.setAutoDelete( FALSE ); + widgets.setAutoDelete( TRUE ); + + updateRowWidgets( row1 ); + updateRowWidgets( row2 ); + if ( curRow == row1 ) + curRow = row2; + else if ( curRow == row2 ) + curRow = row1; + if ( editRow == row1 ) + editRow = row2; + else if ( editRow == row2 ) + editRow = row1; +} + +/*! + Sets the left margin to be \a 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. + + \sa leftMargin() setTopMargin() verticalHeader() +*/ + +void TQTable::setLeftMargin( int m ) +{ + if ( TQApplication::reverseLayout() ) + setMargins( leftMargin(), topMargin(), m, bottomMargin() ); + else + setMargins( m, topMargin(), rightMargin(), bottomMargin() ); + updateGeometries(); +} + +/*! + Sets the top margin to be \a m pixels high. + + The horizontalHeader(), which displays column labels, occupies + this margin. + + \sa topMargin() setLeftMargin() +*/ + +void TQTable::setTopMargin( int m ) +{ + setMargins( leftMargin(), m, rightMargin(), bottomMargin() ); + updateGeometries(); +} + +/*! + Swaps the data in \a col1 with \a 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 \l{TQTableItem}s and want your users to be able to + swap columns you will need to reimplement this function. (See the + notes on large tables.) + + If \a swapHeader is TRUE, the columns' header contents is also + swapped. + + \sa swapCells() +*/ + +void TQTable::swapColumns( int col1, int col2, bool swapHeader ) +{ + if ( swapHeader ) + topHeader->swapSections( col1, col2, FALSE ); + + TQPtrVector<TQTableItem> tmpContents; + tmpContents.resize( numRows() ); + TQPtrVector<TQWidget> tmpWidgets; + tmpWidgets.resize( numRows() ); + int i; + + contents.setAutoDelete( FALSE ); + widgets.setAutoDelete( FALSE ); + for ( i = 0; i < numRows(); ++i ) { + TQTableItem *i1, *i2; + i1 = item( i, col1 ); + i2 = item( i, col2 ); + if ( i1 || i2 ) { + tmpContents.insert( i, i1 ); + contents.remove( indexOf( i, col1 ) ); + contents.insert( indexOf( i, col1 ), i2 ); + contents.remove( indexOf( i, col2 ) ); + contents.insert( indexOf( i, col2 ), tmpContents[ i ] ); + if ( contents[ indexOf( i, col1 ) ] ) + contents[ indexOf( i, col1 ) ]->setCol( col1 ); + if ( contents[ indexOf( i, col2 ) ] ) + contents[ indexOf( i, col2 ) ]->setCol( col2 ); + } + + TQWidget *w1, *w2; + w1 = cellWidget( i, col1 ); + w2 = cellWidget( i, col2 ); + if ( w1 || w2 ) { + tmpWidgets.insert( i, w1 ); + widgets.remove( indexOf( i, col1 ) ); + widgets.insert( indexOf( i, col1 ), w2 ); + widgets.remove( indexOf( i, col2 ) ); + widgets.insert( indexOf( i, col2 ), tmpWidgets[ i ] ); + } + } + contents.setAutoDelete( FALSE ); + widgets.setAutoDelete( TRUE ); + + columnWidthChanged( col1 ); + columnWidthChanged( col2 ); + if ( curCol == col1 ) + curCol = col2; + else if ( curCol == col2 ) + curCol = col1; + if ( editCol == col1 ) + editCol = col2; + else if ( editCol == col2 ) + editCol = col1; +} + +/*! + Swaps the contents of the cell at \a row1, \a col1 with the + contents of the cell at \a row2, \a col2. + + This function is also called when the table is sorted. + + If you don't use \l{TQTableItem}s and want your users to be able to + swap cells, you will need to reimplement this function. (See the + notes on large tables.) + + \sa swapColumns() swapRows() +*/ + +void TQTable::swapCells( int row1, int col1, int row2, int col2 ) +{ + contents.setAutoDelete( FALSE ); + widgets.setAutoDelete( FALSE ); + TQTableItem *i1, *i2; + i1 = item( row1, col1 ); + i2 = item( row2, col2 ); + if ( i1 || i2 ) { + TQTableItem *tmp = i1; + contents.remove( indexOf( row1, col1 ) ); + contents.insert( indexOf( row1, col1 ), i2 ); + contents.remove( indexOf( row2, col2 ) ); + contents.insert( indexOf( row2, col2 ), tmp ); + if ( contents[ indexOf( row1, col1 ) ] ) { + contents[ indexOf( row1, col1 ) ]->setRow( row1 ); + contents[ indexOf( row1, col1 ) ]->setCol( col1 ); + } + if ( contents[ indexOf( row2, col2 ) ] ) { + contents[ indexOf( row2, col2 ) ]->setRow( row2 ); + contents[ indexOf( row2, col2 ) ]->setCol( col2 ); + } + } + + TQWidget *w1, *w2; + w1 = cellWidget( row1, col1 ); + w2 = cellWidget( row2, col2 ); + if ( w1 || w2 ) { + TQWidget *tmp = w1; + widgets.remove( indexOf( row1, col1 ) ); + widgets.insert( indexOf( row1, col1 ), w2 ); + widgets.remove( indexOf( row2, col2 ) ); + widgets.insert( indexOf( row2, col2 ), tmp ); + } + + updateRowWidgets( row1 ); + updateRowWidgets( row2 ); + updateColWidgets( col1 ); + updateColWidgets( col2 ); + contents.setAutoDelete( FALSE ); + widgets.setAutoDelete( TRUE ); +} + +static bool is_child_of( TQWidget *child, TQWidget *tqparent ) +{ + while ( child ) { + if ( child == tqparent ) + return TRUE; + child = child->parentWidget(); + } + return FALSE; +} + +/*! + Draws the table contents on the painter \a p. This function is + optimized so that it only draws the cells inside the \a cw pixels + wide and \a ch pixels high clipping rectangle at position \a cx, + \a cy. + + Additionally, drawContents() highlights the current cell. +*/ + +void TQTable::drawContents( TQPainter *p, int cx, int cy, int cw, int ch ) +{ + int colfirst = columnAt( cx ); + int collast = columnAt( cx + cw ); + int rowfirst = rowAt( cy ); + int rowlast = rowAt( cy + ch ); + + if ( rowfirst == -1 || colfirst == -1 ) { + paintEmptyArea( p, cx, cy, cw, ch ); + return; + } + + drawActiveSelection = hasFocus() || viewport()->hasFocus() || d->inMenuMode + || is_child_of( tqApp->tqfocusWidget(), viewport() ) + || !tqstyle().tqstyleHint( TQStyle::SH_ItemView_ChangeHighlightOnFocus, this ); + if ( rowlast == -1 ) + rowlast = numRows() - 1; + if ( collast == -1 ) + collast = numCols() - 1; + + bool currentInSelection = FALSE; + + TQPtrListIterator<TQTableSelection> it( selections ); + TQTableSelection *s; + while ( ( s = it.current() ) != 0 ) { + ++it; + if ( s->isActive() && + curRow >= s->topRow() && + curRow <= s->bottomRow() && + curCol >= s->leftCol() && + curCol <= s->rightCol() ) { + currentInSelection = s->topRow() != curRow || s->bottomRow() != curRow || s->leftCol() != curCol || s->rightCol() != curCol; + break; + } + } + + // Go through the rows + for ( int r = rowfirst; r <= rowlast; ++r ) { + // get row position and height + int rowp = rowPos( r ); + int rowh = rowHeight( r ); + + // Go through the columns in row r + // if we know from where to where, go through [colfirst, collast], + // else go through all of them + for ( int c = colfirst; c <= collast; ++c ) { + // get position and width of column c + int colp, colw; + colp = columnPos( c ); + colw = columnWidth( c ); + int oldrp = rowp; + int oldrh = rowh; + + TQTableItem *itm = item( r, c ); + if ( itm && + ( itm->colSpan() > 1 || itm->rowSpan() > 1 ) ) { + bool goon = (r == itm->row() && c == itm->col()) || + (r == rowfirst && c == itm->col()) || + (r == itm->row() && c == colfirst); + if ( !goon ) + continue; + rowp = rowPos( itm->row() ); + rowh = 0; + int i; + for ( i = 0; i < itm->rowSpan(); ++i ) + rowh += rowHeight( i + itm->row() ); + colp = columnPos( itm->col() ); + colw = 0; + for ( i = 0; i < itm->colSpan(); ++i ) + colw += columnWidth( i + itm->col() ); + } + + // Translate painter and draw the cell + p->translate( colp, rowp ); + bool selected = isSelected( r, c ); + if ( focusStl != FollowStyle && selected && !currentInSelection && + r == curRow && c == curCol ) + selected = FALSE; + paintCell( p, r, c, TQRect( colp, rowp, colw, rowh ), selected ); + p->translate( -colp, -rowp ); + + rowp = oldrp; + rowh = oldrh; + + TQWidget *w = cellWidget( r, c ); + TQRect cg( cellGeometry( r, c ) ); + if ( w && w->tqgeometry() != TQRect( contentsToViewport( cg.topLeft() ), cg.size() - TQSize( 1, 1 ) ) ) { + moveChild( w, colp, rowp ); + w->resize( cg.size() - TQSize( 1, 1 ) ); + } + } + } + d->lastVisCol = collast; + d->lastVisRow = rowlast; + + // draw indication of current cell + TQRect focusRect = cellGeometry( curRow, curCol ); + p->translate( focusRect.x(), focusRect.y() ); + paintFocus( p, focusRect ); + p->translate( -focusRect.x(), -focusRect.y() ); + + // Paint empty rects + paintEmptyArea( p, cx, cy, cw, ch ); + + drawActiveSelection = TRUE; +} + +/*! + \reimp + + (Implemented to get rid of a compiler warning.) +*/ + +void TQTable::drawContents( TQPainter * ) +{ +} + +/*! + Returns the tqgeometry of cell \a row, \a col in the cell's + coordinate system. This is a convenience function useful in + paintCell(). It is equivalent to TQRect( TQPoint(0,0), cellGeometry( + row, col).size() ); + + \sa cellGeometry() +*/ + +TQRect TQTable::cellRect( int row, int col ) const +{ + return TQRect( TQPoint(0,0), cellGeometry( row, col ).size() ); +} + +/*! + \overload + + Use the other paintCell() function. This function is only included + for backwards compatibilty. +*/ + +void TQTable::paintCell( TQPainter* p, int row, int col, + const TQRect &cr, bool selected ) +{ + if ( cr.width() == 0 || cr.height() == 0 ) + return; +#if defined(TQ_WS_WIN) + const TQColorGroup &cg = ( !drawActiveSelection && tqstyle().tqstyleHint( TQStyle::SH_ItemView_ChangeHighlightOnFocus ) ? tqpalette().inactive() : tqcolorGroup() ); +#else + const TQColorGroup &cg = tqcolorGroup(); +#endif + + TQTableItem *itm = item( row, col ); + TQColorGroup cg2( cg ); + if ( itm && !itm->isEnabled() ) + cg2 = tqpalette().disabled(); + + paintCell( p, row, col, cr, selected, cg2 ); +} + +/*! + Paints the cell at \a row, \a col on the painter \a p. The painter + has already been translated to the cell's origin. \a cr describes + the cell coordinates in the content coordinate system. + + If \a selected is TRUE the cell is highlighted. + + \a 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 + TQTableItem and reimplement TQTableItem::paint() to do the custom + drawing. + + If you're using a TQTableItem subclass, for example, to store a + data structure, then reimplementing TQTableItem::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 \l{TQTableItem}s, 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: + + \code + p->setClipRect( cellRect(row, col), TQPainter::CoordPainter ); + //... your drawing code + p->setClipping( FALSE ); + \endcode +*/ + +void TQTable::paintCell( TQPainter *p, int row, int col, + const TQRect &cr, bool selected, const TQColorGroup &cg ) +{ + if ( focusStl == SpreadSheet && selected && + row == curRow && + col == curCol && ( hasFocus() || viewport()->hasFocus() ) ) + selected = FALSE; + + int w = cr.width(); + int h = cr.height(); + int x2 = w - 1; + int y2 = h - 1; + + + TQTableItem *itm = item( row, col ); + if ( itm ) { + p->save(); + itm->paint( p, cg, cr, selected ); + p->restore(); + } else { + p->fillRect( 0, 0, w, h, selected ? cg.brush( TQColorGroup::Highlight ) : cg.brush( TQColorGroup::Base ) ); + } + + if ( sGrid ) { + // Draw our lines + TQPen pen( p->pen() ); + int gridColor = tqstyle().tqstyleHint( TQStyle::SH_Table_GridLineColor, this ); + if (gridColor != -1) { + const TQPalette &pal = tqpalette(); + if (cg != tqcolorGroup() + && cg != pal.disabled() + && cg != pal.inactive()) + p->setPen(cg.mid()); + else + p->setPen((TQRgb)gridColor); + } else { + p->setPen(cg.mid()); + } + p->drawLine( x2, 0, x2, y2 ); + p->drawLine( 0, y2, x2, y2 ); + p->setPen( pen ); + } +} + +/*! + Draws the focus rectangle of the current cell (see currentRow(), + currentColumn()). + + The painter \a p is already translated to the cell's origin, while + \a cr specifies the cell's tqgeometry in content coordinates. +*/ + +void TQTable::paintFocus( TQPainter *p, const TQRect &cr ) +{ + if ( !hasFocus() && !viewport()->hasFocus() ) + return; + TQRect focusRect( 0, 0, cr.width(), cr.height() ); + if ( focusStyle() == SpreadSheet ) { + p->setPen( TQPen( Qt::black, 1 ) ); + p->setBrush( Qt::NoBrush ); + p->drawRect( focusRect.x(), focusRect.y(), focusRect.width() - 1, focusRect.height() - 1 ); + p->drawRect( focusRect.x() - 1, focusRect.y() - 1, focusRect.width() + 1, focusRect.height() + 1 ); + } else { + TQColor c = isSelected( curRow, curCol, FALSE ) ? + tqcolorGroup().highlight() : tqcolorGroup().base(); + tqstyle().tqdrawPrimitive( TQStyle::PE_FocusRect, p, focusRect, tqcolorGroup(), + ( isSelected( curRow, curCol, FALSE ) ? + TQStyle::Style_FocusAtBorder : + TQStyle::Style_Default ), + TQStyleOption(c) ); + } +} + +/*! + This function fills the \a cw pixels wide and \a ch pixels high + rectangle starting at position \a cx, \a cy with the background + color using the painter \a p. + + paintEmptyArea() is invoked by drawContents() to erase or fill + unused areas. +*/ + +void TQTable::paintEmptyArea( TQPainter *p, int cx, int cy, int cw, int ch ) +{ + // Regions work with shorts, so avoid an overflow and adjust the + // table size to the visible size + TQSize ts( tableSize() ); + ts.setWidth( TQMIN( ts.width(), visibleWidth() ) ); + ts.setHeight( TQMIN( ts.height(), visibleHeight() ) ); + + // Region of the rect we should draw, calculated in viewport + // coordinates, as a region can't handle bigger coordinates + contentsToViewport2( cx, cy, cx, cy ); + TQRegion reg( TQRect( cx, cy, cw, ch ) ); + + // Subtract the table from it + reg = reg.subtract( TQRect( TQPoint( 0, 0 ), ts ) ); + + // And draw the rectangles (transformed inc contents coordinates as needed) + TQMemArray<TQRect> r = reg.tqrects(); + for ( int i = 0; i < (int)r.count(); ++i ) + p->fillRect( TQRect(viewportToContents2(r[i].topLeft()),r[i].size()), viewport()->backgroundBrush() ); +} + +/*! + Returns the TQTableItem representing the contents of the cell at \a + row, \a col. + + If \a row or \a col are out of range or no content has been set + for this cell, item() returns 0. + + If you don't use \l{TQTableItem}s you may need to reimplement this + function: see the notes on large tables. + + \sa setItem() +*/ + +TQTableItem *TQTable::item( int row, int col ) const +{ + if ( row < 0 || col < 0 || row > numRows() - 1 || + col > numCols() - 1 || row * col >= (int)contents.size() ) + return 0; + + return contents[ indexOf( row, col ) ]; // contents array lookup +} + +/*! + Inserts the table item \a item into the table at row \a row, + column \a col, and repaints the cell. If a table item already + exists in this cell it is deleted and tqreplaced with \a item. The + table takes ownership of the table item. + + If you don't use \l{TQTableItem}s you may need to reimplement this + function: see the notes on large tables. + + \sa item() takeItem() +*/ + +void TQTable::setItem( int row, int col, TQTableItem *item ) +{ + if ( !item ) + return; + + if ( (int)contents.size() != numRows() * numCols() ) + resizeData( numRows() * numCols() ); + + int orow = item->row(); + int ocol = item->col(); + clearCell( row, col ); + + contents.insert( indexOf( row, col ), item ); + item->setRow( row ); + item->setCol( col ); + item->t = this; + updateCell( row, col ); + if ( qt_update_cell_widget ) + item->updateEditor( orow, ocol ); + + if ( row == curRow && col == curCol && item->editType() == TQTableItem::WhenCurrent ) { + if ( beginEdit( row, col, FALSE ) ) + setEditMode( Editing, row, col ); + } +} + +/*! + Removes the TQTableItem at \a row, \a col. + + If you don't use \l{TQTableItem}s you may need to reimplement this + function: see the notes on large tables. +*/ + +void TQTable::clearCell( int row, int col ) +{ + if ( (int)contents.size() != numRows() * numCols() ) + resizeData( numRows() * numCols() ); + clearCellWidget( row, col ); + contents.setAutoDelete( TRUE ); + contents.remove( indexOf( row, col ) ); + contents.setAutoDelete( FALSE ); +} + +/*! + Sets the text in the cell at \a row, \a col to \a text. + + If the cell does not contain a table item a TQTableItem is created + with an \link TQTableItem::EditType EditType\endlink of \c OnTyping, + otherwise the existing table item's text (if any) is tqreplaced with + \a text. + + \sa text() setPixmap() setItem() TQTableItem::setText() +*/ + +void TQTable::setText( int row, int col, const TQString &text ) +{ + TQTableItem *itm = item( row, col ); + if ( itm ) { + itm->setText( text ); + itm->updateEditor( row, col ); + updateCell( row, col ); + } else { + TQTableItem *i = new TQTableItem( this, TQTableItem::OnTyping, + text, TQPixmap() ); + setItem( row, col, i ); + } +} + +/*! + Sets the pixmap in the cell at \a row, \a col to \a pix. + + If the cell does not contain a table item a TQTableItem is created + with an \link TQTableItem::EditType EditType\endlink of \c OnTyping, + otherwise the existing table item's pixmap (if any) is tqreplaced + with \a pix. + + Note that \l{TQComboTableItem}s and \l{TQCheckTableItem}s don't show + pixmaps. + + \sa pixmap() setText() setItem() TQTableItem::setPixmap() +*/ + +void TQTable::setPixmap( int row, int col, const TQPixmap &pix ) +{ + TQTableItem *itm = item( row, col ); + if ( itm ) { + itm->setPixmap( pix ); + updateCell( row, col ); + } else { + TQTableItem *i = new TQTableItem( this, TQTableItem::OnTyping, + TQString::null, pix ); + setItem( row, col, i ); + } +} + +/*! + Returns the text in the cell at \a row, \a col, or TQString::null + if the relevant item does not exist or has no text. + + \sa setText() setPixmap() +*/ + +TQString TQTable::text( int row, int col ) const +{ + TQTableItem *itm = item( row, col ); + if ( itm ) + return itm->text(); + return TQString::null; +} + +/*! + Returns the pixmap set for the cell at \a row, \a col, or a + null-pixmap if the cell tqcontains no pixmap. + + \sa setPixmap() +*/ + +TQPixmap TQTable::pixmap( int row, int col ) const +{ + TQTableItem *itm = item( row, col ); + if ( itm ) + return itm->pixmap(); + return TQPixmap(); +} + +/*! + Moves the focus to the cell at \a row, \a col. + + \sa currentRow() currentColumn() +*/ + +void TQTable::setCurrentCell( int row, int col ) +{ + setCurrentCell( row, col, TRUE, TRUE ); +} + +// need to use a define, as leftMargin() is protected +#define VERTICALMARGIN \ +( TQApplication::reverseLayout() ? \ + rightMargin() \ + : \ + leftMargin() \ +) + +/*! \internal */ + +void TQTable::setCurrentCell( int row, int col, bool updateSelections, bool ensureVisible ) +{ + TQTableItem *oldItem = item( curRow, curCol ); + + if ( row > numRows() - 1 ) + row = numRows() - 1; + if ( col > numCols() - 1 ) + col = numCols() - 1; + + if ( curRow == row && curCol == col ) + return; + + + TQTableItem *itm = oldItem; + if ( itm && itm->editType() != TQTableItem::Always && itm->editType() != TQTableItem::Never ) + endEdit( itm->row(), itm->col(), TRUE, FALSE ); + int oldRow = curRow; + int oldCol = curCol; + curRow = row; + curCol = col; + repaintCell( oldRow, oldCol ); + repaintCell( curRow, curCol ); + if ( ensureVisible ) + ensureCellVisible( curRow, curCol ); + emit currentChanged( row, col ); + + if ( oldCol != curCol ) { + if ( !isColumnSelected( oldCol ) ) + topHeader->setSectionState( oldCol, TQTableHeader::Normal ); + else if ( isRowSelection( selectionMode() ) ) + topHeader->setSectionState( oldCol, TQTableHeader::Selected ); + topHeader->setSectionState( curCol, isColumnSelected( curCol, TRUE ) ? + TQTableHeader::Selected : TQTableHeader::Bold ); + } + + if ( oldRow != curRow ) { + if ( !isRowSelected( oldRow ) ) + leftHeader->setSectionState( oldRow, TQTableHeader::Normal ); + leftHeader->setSectionState( curRow, isRowSelected( curRow, TRUE ) ? + TQTableHeader::Selected : TQTableHeader::Bold ); + } + + itm = item( curRow, curCol ); + + TQPoint cellPos( columnPos( curCol ) + leftMargin() - contentsX(), + rowPos( curRow ) + topMargin() - contentsY() ); + setMicroFocusHint( cellPos.x(), cellPos.y(), columnWidth( curCol ), + rowHeight( curRow ), ( itm && itm->editType() != TQTableItem::Never ) ); + + if ( cellWidget( oldRow, oldCol ) && + cellWidget( oldRow, oldCol )->hasFocus() ) + viewport()->setFocus(); + + if ( itm && itm->editType() == TQTableItem::WhenCurrent ) { + if ( beginEdit( itm->row(), itm->col(), FALSE ) ) + setEditMode( Editing, itm->row(), itm->col() ); + } else if ( itm && itm->editType() == TQTableItem::Always ) { + if ( cellWidget( itm->row(), itm->col() ) ) + cellWidget( itm->row(), itm->col() )->setFocus(); + } + + if ( updateSelections && isRowSelection( selectionMode() ) && + !isSelected( curRow, curCol, FALSE ) ) { + if ( selectionMode() == TQTable::SingleRow ) + clearSelection(); + currentSel = new TQTableSelection(); + selections.append( currentSel ); + currentSel->init( curRow, 0 ); + currentSel->expandTo( curRow, numCols() - 1 ); + repaintSelections( 0, currentSel ); + } +} + +/*! + Scrolls the table until the cell at \a row, \a col becomes + visible. +*/ + +void TQTable::ensureCellVisible( int row, int col ) +{ + if ( !isUpdatesEnabled() || !viewport()->isUpdatesEnabled() ) + return; + int cw = columnWidth( col ); + int rh = rowHeight( row ); + if ( cw < visibleWidth() ) + ensureVisible( columnPos( col ) + cw / 2, rowPos( row ) + rh / 2, cw / 2, rh / 2 ); + else + ensureVisible( columnPos( col ), rowPos( row ) + rh / 2, 0, rh / 2 ); +} + +/*! + Returns TRUE if the cell at \a row, \a col is selected; otherwise + returns FALSE. + + \sa isRowSelected() isColumnSelected() +*/ + +bool TQTable::isSelected( int row, int col ) const +{ + return isSelected( row, col, TRUE ); +} + +/*! \internal */ + +bool TQTable::isSelected( int row, int col, bool includeCurrent ) const +{ + TQPtrListIterator<TQTableSelection> it( selections ); + TQTableSelection *s; + while ( ( s = it.current() ) != 0 ) { + ++it; + if ( s->isActive() && + row >= s->topRow() && + row <= s->bottomRow() && + col >= s->leftCol() && + col <= s->rightCol() ) + return TRUE; + if ( includeCurrent && row == currentRow() && col == currentColumn() ) + return TRUE; + } + return FALSE; +} + +/*! + Returns TRUE if row \a row is selected; otherwise returns FALSE. + + If \a full is FALSE (the default), 'row is selected' means that at + least one cell in the row is selected. If \a full is TRUE, then 'row + is selected' means every cell in the row is selected. + + \sa isColumnSelected() isSelected() +*/ + +bool TQTable::isRowSelected( int row, bool full ) const +{ + if ( !full ) { + TQPtrListIterator<TQTableSelection> it( selections ); + TQTableSelection *s; + while ( ( s = it.current() ) != 0 ) { + ++it; + if ( s->isActive() && + row >= s->topRow() && + row <= s->bottomRow() ) + return TRUE; + if ( row == currentRow() ) + return TRUE; + } + } else { + TQPtrListIterator<TQTableSelection> it( selections ); + TQTableSelection *s; + while ( ( s = it.current() ) != 0 ) { + ++it; + if ( s->isActive() && + row >= s->topRow() && + row <= s->bottomRow() && + s->leftCol() == 0 && + s->rightCol() == numCols() - 1 ) + return TRUE; + } + } + return FALSE; +} + +/*! + Returns TRUE if column \a col is selected; otherwise returns FALSE. + + If \a full is FALSE (the default), 'column is selected' means that + at least one cell in the column is selected. If \a full is TRUE, + then 'column is selected' means every cell in the column is + selected. + + \sa isRowSelected() isSelected() +*/ + +bool TQTable::isColumnSelected( int col, bool full ) const +{ + if ( !full ) { + TQPtrListIterator<TQTableSelection> it( selections ); + TQTableSelection *s; + while ( ( s = it.current() ) != 0 ) { + ++it; + if ( s->isActive() && + col >= s->leftCol() && + col <= s->rightCol() ) + return TRUE; + if ( col == currentColumn() ) + return TRUE; + } + } else { + TQPtrListIterator<TQTableSelection> it( selections ); + TQTableSelection *s; + while ( ( s = it.current() ) != 0 ) { + ++it; + if ( s->isActive() && + col >= s->leftCol() && + col <= s->rightCol() && + s->topRow() == 0 && + s->bottomRow() == numRows() - 1 ) + return TRUE; + } + } + return FALSE; +} + +/*! + \property TQTable::numSelections + \brief The number of selections. + + \sa currentSelection() +*/ + +int TQTable::numSelections() const +{ + return selections.count(); +} + +/*! + Returns selection number \a num, or an inactive TQTableSelection if \a + num is out of range (see TQTableSelection::isActive()). +*/ + +TQTableSelection TQTable::selection( int num ) const +{ + if ( num < 0 || num >= (int)selections.count() ) + return TQTableSelection(); + + TQTableSelection *s = ( (TQTable*)this )->selections.at( num ); + return *s; +} + +/*! + Adds a selection described by \a s to the table and returns its + number or -1 if the selection is invalid. + + Remember to call TQTableSelection::init() and + TQTableSelection::expandTo() to make the selection valid (see also + TQTableSelection::isActive(), or use the + TQTableSelection(int,int,int,int) constructor). + + \sa numSelections() removeSelection() clearSelection() +*/ + +int TQTable::addSelection( const TQTableSelection &s ) +{ + if ( !s.isActive() ) + return -1; + + const int maxr = numRows()-1; + const int maxc = numCols()-1; + TQTableSelection *sel = new TQTableSelection( TQMIN(s.anchorRow(), maxr), TQMIN(s.anchorCol(), maxc), + TQMIN(s.bottomRow(), maxr), TQMIN(s.rightCol(), maxc) ); + + selections.append( sel ); + + repaintSelections( 0, sel, TRUE, TRUE ); + + emit selectionChanged(); + + return selections.count() - 1; +} + +/*! + If the table has a selection, \a s, this selection is removed from + the table. + + \sa addSelection() numSelections() +*/ + +void TQTable::removeSelection( const TQTableSelection &s ) +{ + selections.setAutoDelete( FALSE ); + for ( TQTableSelection *sel = selections.first(); sel; sel = selections.next() ) { + if ( s == *sel ) { + selections.removeRef( sel ); + repaintSelections( sel, 0, TRUE, TRUE ); + if ( sel == currentSel ) + currentSel = 0; + delete sel; + } + } + selections.setAutoDelete( TRUE ); + emit selectionChanged(); +} + +/*! + \overload + + Removes selection number \a num from the table. + + \sa numSelections() addSelection() clearSelection() +*/ + +void TQTable::removeSelection( int num ) +{ + if ( num < 0 || num >= (int)selections.count() ) + return; + + TQTableSelection *s = selections.at( num ); + if ( s == currentSel ) + currentSel = 0; + selections.removeRef( s ); + repaintContents( FALSE ); +} + +/*! + Returns the number of the current selection or -1 if there is no + current selection. + + \sa numSelections() +*/ + +int TQTable::currentSelection() const +{ + if ( !currentSel ) + return -1; + return ( (TQTable*)this )->selections.tqfindRef( currentSel ); +} + +/*! Selects the range starting at \a start_row and \a start_col and + ending at \a end_row and \a end_col. + + \sa TQTableSelection +*/ + +void TQTable::selectCells( int start_row, int start_col, int end_row, int end_col ) +{ + const int maxr = numRows()-1; + const int maxc = numCols()-1; + + start_row = TQMIN( maxr, TQMAX( 0, start_row ) ); + start_col = TQMIN( maxc, TQMAX( 0, start_col ) ); + end_row = TQMIN( maxr, end_row ); + end_col = TQMIN( maxc, end_col ); + TQTableSelection sel( start_row, start_col, end_row, end_col ); + addSelection( sel ); +} + +/*! Selects the row \a row. + + \sa TQTableSelection +*/ + +// ### Make this virtual in 4.0 and remove hack for TQDataTable +void TQTable::selectRow( int row ) +{ + row = TQMIN(numRows()-1, row); + if ( row < 0 ) + return; + bool isDataTable = FALSE; +#ifndef TQT_NO_SQL + isDataTable = ::tqqt_cast<TQDataTable*>(this) != 0; +#endif + if ( isDataTable || selectionMode() == SingleRow ) { + setCurrentCell( row, currentColumn() ); + } else { + TQTableSelection sel( row, 0, row, numCols() - 1 ); + addSelection( sel ); + } +} + +/*! Selects the column \a col. + + \sa TQTableSelection +*/ + +// ### Make this virtual in 4.0 +void TQTable::selectColumn( int col ) +{ + col = TQMIN(numCols()-1, col); + TQTableSelection sel( 0, col, numRows() - 1, col ); + addSelection( sel ); +} + +/*! \reimp +*/ +void TQTable::contentsMousePressEvent( TQMouseEvent* e ) +{ + contentsMousePressEventEx( e ); +} + +void TQTable::contentsMousePressEventEx( TQMouseEvent* e ) +{ + shouldClearSelection = FALSE; + if ( isEditing() ) { + if ( !cellGeometry( editRow, editCol ).tqcontains( e->pos() ) ) { + endEdit( editRow, editCol, TRUE, edMode != Editing ); + } else { + e->ignore(); + return; + } + } + + d->redirectMouseEvent = FALSE; + + int tmpRow = rowAt( e->pos().y() ); + int tmpCol = columnAt( e->pos().x() ); + pressedRow = tmpRow; + pressedCol = tmpCol; + fixRow( tmpRow, e->pos().y() ); + fixCol( tmpCol, e->pos().x() ); + startDragCol = -1; + startDragRow = -1; + + if ( isSelected( tmpRow, tmpCol ) ) { + startDragCol = tmpCol; + startDragRow = tmpRow; + dragStartPos = e->pos(); + } + + TQTableItem *itm = item( pressedRow, pressedCol ); + if ( itm && !itm->isEnabled() ) { + emit pressed( tmpRow, tmpCol, e->button(), e->pos() ); + return; + } + + if ( ( e->state() & ShiftButton ) == ShiftButton ) { + int oldRow = curRow; + int oldCol = curCol; + setCurrentCell( tmpRow, tmpCol, selMode == SingleRow, TRUE ); + if ( selMode != NoSelection && selMode != SingleRow ) { + if ( !currentSel ) { + currentSel = new TQTableSelection(); + selections.append( currentSel ); + if ( !isRowSelection( selectionMode() ) ) + currentSel->init( oldRow, oldCol ); + else + currentSel->init( oldRow, 0 ); + } + TQTableSelection oldSelection = *currentSel; + if ( !isRowSelection( selectionMode() ) ) + currentSel->expandTo( tmpRow, tmpCol ); + else + currentSel->expandTo( tmpRow, numCols() - 1 ); + repaintSelections( &oldSelection, currentSel ); + emit selectionChanged(); + } + } else if ( ( e->state() & ControlButton ) == ControlButton ) { + setCurrentCell( tmpRow, tmpCol, FALSE, TRUE ); + if ( selMode != NoSelection ) { + if ( selMode == Single || (selMode == SingleRow && !isSelected( tmpRow, tmpCol, FALSE )) ) + clearSelection(); + if ( !(selMode == SingleRow && isSelected( tmpRow, tmpCol, FALSE )) ) { + currentSel = new TQTableSelection(); + selections.append( currentSel ); + if ( !isRowSelection( selectionMode() ) ) { + currentSel->init( tmpRow, tmpCol ); + currentSel->expandTo( tmpRow, tmpCol ); + } else { + currentSel->init( tmpRow, 0 ); + currentSel->expandTo( tmpRow, numCols() - 1 ); + repaintSelections( 0, currentSel ); + } + emit selectionChanged(); + } + } + } else { + setCurrentCell( tmpRow, tmpCol, FALSE, TRUE ); + TQTableItem *itm = item( tmpRow, tmpCol ); + if ( itm && itm->editType() == TQTableItem::WhenCurrent ) { + TQWidget *w = cellWidget( tmpRow, tmpCol ); + if ( ::tqqt_cast<TQComboBox*>(w) || ::tqqt_cast<TQButton*>(w) ) { + TQMouseEvent ev( e->type(), w->mapFromGlobal( e->globalPos() ), + e->globalPos(), e->button(), e->state() ); + TQApplication::sendPostedEvents( w, 0 ); + TQApplication::sendEvent( w, &ev ); + d->redirectMouseEvent = TRUE; + } + } + if ( isSelected( tmpRow, tmpCol, FALSE ) ) { + shouldClearSelection = TRUE; + } else { + bool b = tqsignalsBlocked(); + if ( selMode != NoSelection ) + blockSignals( TRUE ); + clearSelection(); + blockSignals( b ); + if ( selMode != NoSelection ) { + currentSel = new TQTableSelection(); + selections.append( currentSel ); + if ( !isRowSelection( selectionMode() ) ) { + currentSel->init( tmpRow, tmpCol ); + currentSel->expandTo( tmpRow, tmpCol ); + } else { + currentSel->init( tmpRow, 0 ); + currentSel->expandTo( tmpRow, numCols() - 1 ); + repaintSelections( 0, currentSel ); + } + emit selectionChanged(); + } + } + } + + emit pressed( tmpRow, tmpCol, e->button(), e->pos() ); +} + +/*! \reimp +*/ + +void TQTable::contentsMouseDoubleClickEvent( TQMouseEvent *e ) +{ + if ( e->button() != Qt::LeftButton ) + return; + if ( !isRowSelection( selectionMode() ) ) + clearSelection(); + int tmpRow = rowAt( e->pos().y() ); + int tmpCol = columnAt( e->pos().x() ); + TQTableItem *itm = item( tmpRow, tmpCol ); + if ( itm && !itm->isEnabled() ) + return; + if ( tmpRow != -1 && tmpCol != -1 ) { + if ( beginEdit( tmpRow, tmpCol, FALSE ) ) + setEditMode( Editing, tmpRow, tmpCol ); + } + + emit doubleClicked( tmpRow, tmpCol, e->button(), e->pos() ); +} + +/*! + Sets the current edit mode to \a mode, the current edit row to \a + row and the current edit column to \a col. + + \sa EditMode +*/ + +void TQTable::setEditMode( EditMode mode, int row, int col ) +{ + edMode = mode; + editRow = row; + editCol = col; +} + + +/*! \reimp +*/ + +void TQTable::contentsMouseMoveEvent( TQMouseEvent *e ) +{ + if ( (e->state() & Qt::MouseButtonMask) == Qt::NoButton ) + return; + int tmpRow = rowAt( e->pos().y() ); + int tmpCol = columnAt( e->pos().x() ); + fixRow( tmpRow, e->pos().y() ); + fixCol( tmpCol, e->pos().x() ); + +#ifndef TQT_NO_DRAGANDDROP + if ( dragEnabled() && startDragRow != -1 && startDragCol != -1 ) { + if (TQPoint(dragStartPos - e->pos()).manhattanLength() > TQApplication::startDragDistance()) + startDrag(); + return; + } +#endif + if ( selectionMode() == MultiRow && ( e->state() & ControlButton ) == ControlButton ) + shouldClearSelection = FALSE; + + if ( shouldClearSelection ) { + clearSelection(); + if ( selMode != NoSelection ) { + currentSel = new TQTableSelection(); + selections.append( currentSel ); + if ( !isRowSelection( selectionMode() ) ) + currentSel->init( tmpRow, tmpCol ); + else + currentSel->init( tmpRow, 0 ); + emit selectionChanged(); + } + shouldClearSelection = FALSE; + } + + TQPoint pos = mapFromGlobal( e->globalPos() ); + pos -= TQPoint( leftHeader->width(), topHeader->height() ); + autoScrollTimer->stop(); + doAutoScroll(); + if ( pos.x() < 0 || pos.x() > visibleWidth() || pos.y() < 0 || pos.y() > visibleHeight() ) + autoScrollTimer->start( 100, TRUE ); +} + +/*! \internal + */ + +void TQTable::doValueChanged() +{ + emit valueChanged( editRow, editCol ); +} + +/*! \internal +*/ + +void TQTable::doAutoScroll() +{ + TQPoint pos = TQCursor::pos(); + pos = mapFromGlobal( pos ); + pos -= TQPoint( leftHeader->width(), topHeader->height() ); + + int tmpRow = curRow; + int tmpCol = curCol; + if ( pos.y() < 0 ) + tmpRow--; + else if ( pos.y() > visibleHeight() ) + tmpRow++; + if ( pos.x() < 0 ) + tmpCol--; + else if ( pos.x() > visibleWidth() ) + tmpCol++; + + pos += TQPoint( contentsX(), contentsY() ); + if ( tmpRow == curRow ) + tmpRow = rowAt( pos.y() ); + if ( tmpCol == curCol ) + tmpCol = columnAt( pos.x() ); + pos -= TQPoint( contentsX(), contentsY() ); + + fixRow( tmpRow, pos.y() ); + fixCol( tmpCol, pos.x() ); + + if ( tmpRow < 0 || tmpRow > numRows() - 1 ) + tmpRow = currentRow(); + if ( tmpCol < 0 || tmpCol > numCols() - 1 ) + tmpCol = currentColumn(); + + ensureCellVisible( tmpRow, tmpCol ); + + if ( currentSel && selMode != NoSelection ) { + TQTableSelection oldSelection = *currentSel; + bool useOld = TRUE; + if ( selMode != SingleRow ) { + if ( !isRowSelection( selectionMode() ) ) { + currentSel->expandTo( tmpRow, tmpCol ); + } else { + currentSel->expandTo( tmpRow, numCols() - 1 ); + } + } else { + bool currentInSelection = tmpRow == curRow && isSelected( tmpRow, tmpCol ); + if ( !currentInSelection ) { + useOld = FALSE; + clearSelection(); + currentSel = new TQTableSelection(); + selections.append( currentSel ); + currentSel->init( tmpRow, 0 ); + currentSel->expandTo( tmpRow, numCols() - 1 ); + repaintSelections( 0, currentSel ); + } else { + currentSel->expandTo( tmpRow, numCols() - 1 ); + } + } + setCurrentCell( tmpRow, tmpCol, FALSE, TRUE ); + repaintSelections( useOld ? &oldSelection : 0, currentSel ); + if ( currentSel && oldSelection != *currentSel ) + emit selectionChanged(); + } else { + setCurrentCell( tmpRow, tmpCol, FALSE, TRUE ); + } + + if ( pos.x() < 0 || pos.x() > visibleWidth() || pos.y() < 0 || pos.y() > visibleHeight() ) + autoScrollTimer->start( 100, TRUE ); +} + +/*! \reimp +*/ + +void TQTable::contentsMouseReleaseEvent( TQMouseEvent *e ) +{ + if ( pressedRow == curRow && pressedCol == curCol ) + emit clicked( curRow, curCol, e->button(), e->pos() ); + + if ( e->button() != Qt::LeftButton ) + return; + if ( shouldClearSelection ) { + int tmpRow = rowAt( e->pos().y() ); + int tmpCol = columnAt( e->pos().x() ); + fixRow( tmpRow, e->pos().y() ); + fixCol( tmpCol, e->pos().x() ); + clearSelection(); + if ( selMode != NoSelection ) { + currentSel = new TQTableSelection(); + selections.append( currentSel ); + if ( !isRowSelection( selectionMode() ) ) { + currentSel->init( tmpRow, tmpCol ); + } else { + currentSel->init( tmpRow, 0 ); + currentSel->expandTo( tmpRow, numCols() - 1 ); + repaintSelections( 0, currentSel ); + } + emit selectionChanged(); + } + shouldClearSelection = FALSE; + } + autoScrollTimer->stop(); + + if ( d->redirectMouseEvent && pressedRow == curRow && pressedCol == curCol && + item( pressedRow, pressedCol ) && item( pressedRow, pressedCol )->editType() == + TQTableItem::WhenCurrent ) { + TQWidget *w = cellWidget( pressedRow, pressedCol ); + if ( w ) { + TQMouseEvent ev( e->type(), w->mapFromGlobal( e->globalPos() ), + e->globalPos(), e->button(), e->state() ); + TQApplication::sendPostedEvents( w, 0 ); + TQApplication::sendEvent( w, &ev ); + } + } +} + +/*! + \reimp +*/ + +void TQTable::contentsContextMenuEvent( TQContextMenuEvent *e ) +{ + if ( !tqreceivers( TQT_SIGNAL(contextMenuRequested(int,int,const TQPoint&)) ) ) { + e->ignore(); + return; + } + if ( e->reason() == TQContextMenuEvent::Keyboard ) { + TQRect r = cellGeometry( curRow, curCol ); + emit contextMenuRequested( curRow, curCol, viewport()->mapToGlobal( contentsToViewport( r.center() ) ) ); + } else { + int tmpRow = rowAt( e->pos().y() ); + int tmpCol = columnAt( e->pos().x() ); + emit contextMenuRequested( tmpRow, tmpCol, e->globalPos() ); + } +} + + +/*! \reimp +*/ + +bool TQTable::eventFilter( TQObject *o, TQEvent *e ) +{ + TQWidget *editorWidget = cellWidget( editRow, editCol ); + switch ( e->type() ) { + case TQEvent::KeyPress: { + TQTableItem *itm = item( curRow, curCol ); + int editRow = this->editRow; + int editCol = this->editCol; + if ((d->hasRowSpan || d->hasColSpan) && !editorWidget) { + if (TQTableItem *eitm = item(editRow, editCol)) { + editRow = eitm->row(); + editCol = eitm->col(); + editorWidget = cellWidget(editRow, editCol); + } + } + if ( isEditing() && editorWidget && TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(editorWidget) ) { + itm = item( editRow, editCol ); + TQKeyEvent *ke = (TQKeyEvent*)e; + if ( ke->key() == Key_Escape ) { + if ( !itm || itm->editType() == TQTableItem::OnTyping ) + endEdit( editRow, editCol, FALSE, edMode != Editing ); + return TRUE; + } + + if ( ( ke->state() == Qt::NoButton || ke->state() == TQt::Keypad ) + && ( ke->key() == Qt::Key_Return || ke->key() == Qt::Key_Enter ) ) { + if ( !itm || itm->editType() == TQTableItem::OnTyping ) + endEdit( editRow, editCol, TRUE, edMode != Editing ); + activateNextCell(); + return TRUE; + } + + if ( ke->key() == Qt::Key_Tab || ke->key() == TQt::Key_BackTab ) { + if ( ke->state() & ControlButton ) + return FALSE; + if ( !itm || itm->editType() == TQTableItem::OnTyping ) + endEdit( editRow, editCol, TRUE, edMode != Editing ); + if ( (ke->key() == Qt::Key_Tab) && !(ke->state() & ShiftButton) ) { + if ( currentColumn() >= numCols() - 1 ) + return TRUE; + int cc = TQMIN( numCols() - 1, currentColumn() + 1 ); + while ( cc < numCols() ) { + TQTableItem *i = item( currentRow(), cc ); + if ( !d->hiddenCols.tqfind( cc ) && !isColumnReadOnly( cc ) && (!i || i->isEnabled()) ) + break; + ++cc; + } + setCurrentCell( currentRow(), cc ); + } else { // Qt::Key_BackTab + if ( currentColumn() == 0 ) + return TRUE; + int cc = TQMAX( 0, currentColumn() - 1 ); + while ( cc >= 0 ) { + TQTableItem *i = item( currentRow(), cc ); + if ( !d->hiddenCols.tqfind( cc ) && !isColumnReadOnly( cc ) && (!i || i->isEnabled()) ) + break; + --cc; + } + setCurrentCell( currentRow(), cc ); + } + itm = item( curRow, curCol ); + if ( beginEdit( curRow, curCol, FALSE ) ) + setEditMode( Editing, curRow, curCol ); + return TRUE; + } + + if ( ( edMode == Replacing || + (itm && itm->editType() == TQTableItem::WhenCurrent) ) && + ( ke->key() == Qt::Key_Up || ke->key() == TQt::Key_Prior || + ke->key() == Qt::Key_Home || ke->key() == Qt::Key_Down || + ke->key() == TQt::Key_Next || ke->key() == Qt::Key_End || + ke->key() == Qt::Key_Left || ke->key() == Qt::Key_Right ) ) { + if ( !itm || itm->editType() == TQTableItem::OnTyping ) { + endEdit( editRow, editCol, TRUE, edMode != Editing ); + } + keyPressEvent( ke ); + return TRUE; + } + } else { + TQObjectList *l = viewport()->queryList( "TQWidget" ); + if ( l && l->tqfind( o ) != -1 ) { + delete l; + TQKeyEvent *ke = (TQKeyEvent*)e; + if ( ( ke->state() & ControlButton ) == ControlButton || + ( ke->key() != Qt::Key_Left && ke->key() != Qt::Key_Right && + ke->key() != Qt::Key_Up && ke->key() != Qt::Key_Down && + ke->key() != TQt::Key_Prior && ke->key() != TQt::Key_Next && + ke->key() != Qt::Key_Home && ke->key() != Qt::Key_End ) ) + return FALSE; + keyPressEvent( (TQKeyEvent*)e ); + return TRUE; + } + delete l; + } + + } break; + case TQEvent::FocusOut: + if ( isEditing() && editorWidget && TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(editorWidget) && ( (TQFocusEvent*)e )->reason() != TQFocusEvent::Popup ) { + TQTableItem *itm = item( editRow, editCol ); + if ( !itm || itm->editType() == TQTableItem::OnTyping ) { + endEdit( editRow, editCol, TRUE, edMode != Editing ); + return TRUE; + } + } + break; +#ifndef TQT_NO_WHEELEVENT + case TQEvent::Wheel: + if ( TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(this) || TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(viewport()) ) { + TQWheelEvent* we = (TQWheelEvent*)e; + scrollBy( 0, -we->delta() ); + we->accept(); + return TRUE; + } +#endif + default: + break; + } + + return TQScrollView::eventFilter( o, e ); +} + +void TQTable::fixCell( int &row, int &col, int key ) +{ + if ( rowHeight( row ) > 0 && columnWidth( col ) > 0 ) + return; + if ( rowHeight( row ) <= 0 ) { + if ( key == Qt::Key_Down || + key == TQt::Key_Next || + key == Qt::Key_End ) { + while ( row < numRows() && rowHeight( row ) <= 0 ) + row++; + if ( rowHeight( row ) <= 0 ) + row = curRow; + } else if ( key == Qt::Key_Up || + key == TQt::Key_Prior || + key == Qt::Key_Home ) + while ( row >= 0 && rowHeight( row ) <= 0 ) + row--; + if ( rowHeight( row ) <= 0 ) + row = curRow; + } else if ( columnWidth( col ) <= 0 ) { + if ( key == Qt::Key_Left ) { + while ( col >= 0 && columnWidth( col ) <= 0 ) + col--; + if ( columnWidth( col ) <= 0 ) + col = curCol; + } else if ( key == Qt::Key_Right ) { + while ( col < numCols() && columnWidth( col ) <= 0 ) + col++; + if ( columnWidth( col ) <= 0 ) + col = curCol; + } + } +} + +/*! \reimp +*/ + +void TQTable::keyPressEvent( TQKeyEvent* e ) +{ + if ( isEditing() && item( editRow, editCol ) && + item( editRow, editCol )->editType() == TQTableItem::OnTyping ) + return; + + int tmpRow = curRow; + int tmpCol = curCol; + int oldRow = tmpRow; + int oldCol = tmpCol; + + bool navigationKey = FALSE; + int r; + switch ( e->key() ) { + case Qt::Key_Left: + tmpCol = TQMAX( 0, tmpCol - 1 ); + navigationKey = TRUE; + break; + case Qt::Key_Right: + tmpCol = TQMIN( numCols() - 1, tmpCol + 1 ); + navigationKey = TRUE; + break; + case Qt::Key_Up: + tmpRow = TQMAX( 0, tmpRow - 1 ); + navigationKey = TRUE; + break; + case Qt::Key_Down: + tmpRow = TQMIN( numRows() - 1, tmpRow + 1 ); + navigationKey = TRUE; + break; + case TQt::Key_Prior: + r = TQMAX( 0, rowAt( rowPos( tmpRow ) - visibleHeight() ) ); + if ( r < tmpRow || tmpRow < 0 ) + tmpRow = r; + navigationKey = TRUE; + break; + case TQt::Key_Next: + r = TQMIN( numRows() - 1, rowAt( rowPos( tmpRow ) + visibleHeight() ) ); + if ( r > tmpRow ) + tmpRow = r; + else + tmpRow = numRows() - 1; + navigationKey = TRUE; + break; + case Qt::Key_Home: + tmpRow = 0; + navigationKey = TRUE; + break; + case Qt::Key_End: + tmpRow = numRows() - 1; + navigationKey = TRUE; + break; + case Qt::Key_F2: + if ( beginEdit( tmpRow, tmpCol, FALSE ) ) + setEditMode( Editing, tmpRow, tmpCol ); + break; + case Qt::Key_Enter: case Qt::Key_Return: + activateNextCell(); + return; + case Qt::Key_Tab: case TQt::Key_BackTab: + if ( (e->key() == Qt::Key_Tab) && !(e->state() & ShiftButton) ) { + if ( currentColumn() >= numCols() - 1 ) + return; + int cc = TQMIN( numCols() - 1, currentColumn() + 1 ); + while ( cc < numCols() ) { + TQTableItem *i = item( currentRow(), cc ); + if ( !d->hiddenCols.tqfind( cc ) && !isColumnReadOnly( cc ) && (!i || i->isEnabled()) ) + break; + ++cc; + } + setCurrentCell( currentRow(), cc ); + } else { // Qt::Key_BackTab + if ( currentColumn() == 0 ) + return; + int cc = TQMAX( 0, currentColumn() - 1 ); + while ( cc >= 0 ) { + TQTableItem *i = item( currentRow(), cc ); + if ( !d->hiddenCols.tqfind( cc ) && !isColumnReadOnly( cc ) && (!i || i->isEnabled()) ) + break; + --cc; + } + setCurrentCell( currentRow(), cc ); + } + return; + case Key_Escape: + e->ignore(); + return; + default: // ... or start in-place editing + if ( e->text()[ 0 ].isPrint() ) { + TQTableItem *itm = item( tmpRow, tmpCol ); + if ( !itm || itm->editType() == TQTableItem::OnTyping ) { + TQWidget *w = beginEdit( tmpRow, tmpCol, + itm ? itm->isReplaceable() : TRUE ); + if ( w ) { + setEditMode( ( !itm || (itm && itm->isReplaceable()) + ? Replacing : Editing ), tmpRow, tmpCol ); + TQApplication::sendEvent( w, e ); + return; + } + } + } + e->ignore(); + return; + } + + if ( navigationKey ) { + fixCell( tmpRow, tmpCol, e->key() ); + if ( ( e->state() & ShiftButton ) == ShiftButton && + selMode != NoSelection && selMode != SingleRow ) { + bool justCreated = FALSE; + setCurrentCell( tmpRow, tmpCol, FALSE, TRUE ); + if ( !currentSel ) { + justCreated = TRUE; + currentSel = new TQTableSelection(); + selections.append( currentSel ); + if ( !isRowSelection( selectionMode() ) ) + currentSel->init( oldRow, oldCol ); + else + currentSel->init( oldRow < 0 ? 0 : oldRow, 0 ); + } + TQTableSelection oldSelection = *currentSel; + if ( !isRowSelection( selectionMode() ) ) + currentSel->expandTo( tmpRow, tmpCol ); + else + currentSel->expandTo( tmpRow, numCols() - 1 ); + repaintSelections( justCreated ? 0 : &oldSelection, currentSel ); + emit selectionChanged(); + } else { + setCurrentCell( tmpRow, tmpCol, FALSE, TRUE ); + if ( !isRowSelection( selectionMode() ) ) { + clearSelection(); + } else { + bool currentInSelection = tmpRow == oldRow && isSelected( tmpRow, tmpCol, FALSE ); + if ( !currentInSelection ) { + bool hasOldSel = FALSE; + TQTableSelection oldSelection; + if ( selectionMode() == MultiRow ) { + bool b = tqsignalsBlocked(); + blockSignals( TRUE ); + clearSelection(); + blockSignals( b ); + } else { + if ( currentSel ) { + oldSelection = *currentSel; + hasOldSel = TRUE; + selections.removeRef( currentSel ); + leftHeader->setSectionState( oldSelection.topRow(), TQTableHeader::Normal ); + } + } + currentSel = new TQTableSelection(); + selections.append( currentSel ); + currentSel->init( tmpRow, 0 ); + currentSel->expandTo( tmpRow, numCols() - 1 ); + repaintSelections( hasOldSel ? &oldSelection : 0, currentSel, !hasOldSel ); + emit selectionChanged(); + } + } + } + } else { + setCurrentCell( tmpRow, tmpCol, FALSE, TRUE ); + } +} + +/*! \reimp +*/ + +void TQTable::focusInEvent( TQFocusEvent* ) +{ + d->inMenuMode = FALSE; + TQWidget *editorWidget = cellWidget( editRow, editCol ); + updateCell( curRow, curCol ); + if ( tqstyle().tqstyleHint( TQStyle::SH_ItemView_ChangeHighlightOnFocus, this ) ) + repaintSelections(); + if ( isEditing() && editorWidget ) + editorWidget->setFocus(); + + TQPoint cellPos( columnPos( curCol ) + leftMargin() - contentsX(), rowPos( curRow ) + topMargin() - contentsY() ); + TQTableItem *itm = item( curRow, curCol ); + setMicroFocusHint( cellPos.x(), cellPos.y(), columnWidth( curCol ), rowHeight( curRow ), ( itm && itm->editType() != TQTableItem::Never ) ); +} + + +/*! \reimp +*/ + +void TQTable::focusOutEvent( TQFocusEvent* tqfe ) +{ + updateCell( curRow, curCol ); + if (tqstyle().tqstyleHint( TQStyle::SH_ItemView_ChangeHighlightOnFocus, this )) { + d->inMenuMode = +#ifdef USE_QT4 + tqfe->reason() == TQFocusEvent::Popup || +#else // USE_QT4 + TQFocusEvent::reason() == TQFocusEvent::Popup || +#endif // USE_QT4 + (tqApp->tqfocusWidget() && tqApp->tqfocusWidget()->inherits("TQMenuBar")); + if ( !d->inMenuMode ) + repaintSelections(); + } +} + +/*! \reimp +*/ + +TQSize TQTable::tqsizeHint() const +{ + if ( cachedSizeHint().isValid() ) + return cachedSizeHint(); + + constPolish(); + + TQSize s = tableSize(); + TQSize sh; + if ( s.width() < 500 && s.height() < 500 ) { + sh = TQSize( tableSize().width() + VERTICALMARGIN + 5, + tableSize().height() + topMargin() + 5 ); + } else { + sh = TQScrollView::tqsizeHint(); + if ( !topHeader->isHidden() ) + sh.setHeight( sh.height() + topHeader->height() ); + if ( !leftHeader->isHidden() ) + sh.setWidth( sh.width() + leftHeader->width() ); + } + setCachedSizeHint( sh ); + return sh; +} + +/*! \reimp +*/ + +void TQTable::viewportResizeEvent( TQResizeEvent *e ) +{ + TQScrollView::viewportResizeEvent( e ); + updateGeometries(); +} + +/*! \reimp +*/ + +void TQTable::showEvent( TQShowEvent *e ) +{ + TQScrollView::showEvent( e ); + TQRect r( cellGeometry( numRows() - 1, numCols() - 1 ) ); + resizeContents( r.right() + 1, r.bottom() + 1 ); + updateGeometries(); +} + +/*! \reimp +*/ + +void TQTable::paintEvent( TQPaintEvent *e ) +{ + TQRect topLeftCorner = TQStyle::tqvisualRect( TQRect(frameWidth(), frameWidth(), VERTICALMARGIN, topMargin() ), rect() ); + erase( topLeftCorner ); // erase instead of widget on top + TQScrollView::paintEvent( e ); + +#ifdef TQ_OS_TEMP + TQPainter p( this ); + p.drawLine( topLeftCorner.bottomLeft(), topLeftCorner.bottomRight() ); + p.drawLine( topLeftCorner.bottomRight(), topLeftCorner.topRight() ); +#endif +} + +static bool inUpdateCell = FALSE; + +/*! + Repaints the cell at \a row, \a col. +*/ + +void TQTable::updateCell( int row, int col ) +{ + if ( inUpdateCell || row < 0 || col < 0 ) + return; + inUpdateCell = TRUE; + TQRect cg = cellGeometry( row, col ); + TQRect r( contentsToViewport( TQPoint( cg.x() - 2, cg.y() - 2 ) ), + TQSize( cg.width() + 4, cg.height() + 4 ) ); + if (viewport()->rect().intersects(r)) + TQApplication::postEvent( viewport(), new TQPaintEvent( r, FALSE ) ); + inUpdateCell = FALSE; +} + +void TQTable::repaintCell( int row, int col ) +{ + if ( row == -1 || col == -1 ) + return; + TQRect cg = cellGeometry( row, col ); + TQRect r( TQPoint( cg.x() - 2, cg.y() - 2 ), + TQSize( cg.width() + 4, cg.height() + 4 ) ); + + TQRect v = viewport()->rect(); + v.moveBy(contentsX(), contentsY()); + if (v.intersects(r)) + repaintContents( r, FALSE ); +} + +void TQTable::contentsToViewport2( int x, int y, int& vx, int& vy ) +{ + const TQPoint v = contentsToViewport2( TQPoint( x, y ) ); + vx = v.x(); + vy = v.y(); +} + +TQPoint TQTable::contentsToViewport2( const TQPoint &p ) +{ + return TQPoint( p.x() - contentsX(), + p.y() - contentsY() ); +} + +TQPoint TQTable::viewportToContents2( const TQPoint& vp ) +{ + return TQPoint( vp.x() + contentsX(), + vp.y() + contentsY() ); +} + +void TQTable::viewportToContents2( int vx, int vy, int& x, int& y ) +{ + const TQPoint c = viewportToContents2( TQPoint( vx, vy ) ); + x = c.x(); + y = c.y(); +} + +/*! + This function should be called whenever the column width of \a col + has been changed. It updates the tqgeometry of any affected columns + and repaints the table to reflect the changes it has made. +*/ + +void TQTable::columnWidthChanged( int col ) +{ + int p = columnPos( col ); + if ( d->hasColSpan ) + p = contentsX(); + updateContents( p, contentsY(), contentsWidth(), visibleHeight() ); + TQSize s( tableSize() ); + int w = contentsWidth(); + resizeContents( s.width(), s.height() ); + if ( contentsWidth() < w ) + repaintContents( s.width(), contentsY(), + w - s.width() + 1, visibleHeight(), TRUE ); + else + repaintContents( w, contentsY(), + s.width() - w + 1, visibleHeight(), FALSE ); + + // update widgets that are affected by this change + if ( widgets.size() ) { + int last = isHidden() ? numCols() - 1 : d->lastVisCol; + for ( int c = col; c <= last; ++c ) + updateColWidgets( c ); + } + delayedUpdateGeometries(); +} + +/*! + This function should be called whenever the row height of \a row + has been changed. It updates the tqgeometry of any affected rows and + repaints the table to reflect the changes it has made. +*/ + +void TQTable::rowHeightChanged( int row ) +{ + int p = rowPos( row ); + if ( d->hasRowSpan ) + p = contentsY(); + updateContents( contentsX(), p, visibleWidth(), contentsHeight() ); + TQSize s( tableSize() ); + int h = contentsHeight(); + resizeContents( s.width(), s.height() ); + if ( contentsHeight() < h ) { + repaintContents( contentsX(), contentsHeight(), + visibleWidth(), h - s.height() + 1, TRUE ); + } else { + repaintContents( contentsX(), h, + visibleWidth(), s.height() - h + 1, FALSE ); + } + + // update widgets that are affected by this change + if ( widgets.size() ) { + d->lastVisRow = rowAt( contentsY() + visibleHeight() + ( s.height() - h + 1 ) ); + int last = isHidden() ? numRows() - 1 : d->lastVisRow; + for ( int r = row; r <= last; ++r ) + updateRowWidgets( r ); + } + delayedUpdateGeometries(); +} + +/*! \internal */ + +void TQTable::updateRowWidgets( int row ) +{ + for ( int i = 0; i < numCols(); ++i ) { + TQWidget *w = cellWidget( row, i ); + if ( !w ) + continue; + moveChild( w, columnPos( i ), rowPos( row ) ); + w->resize( columnWidth( i ) - 1, rowHeight( row ) - 1 ); + } +} + +/*! \internal */ + +void TQTable::updateColWidgets( int col ) +{ + for ( int i = 0; i < numRows(); ++i ) { + TQWidget *w = cellWidget( i, col ); + if ( !w ) + continue; + moveChild( w, columnPos( col ), rowPos( i ) ); + w->resize( columnWidth( col ) - 1, rowHeight( i ) - 1 ); + } +} + +/*! + This function is called when column order is to be changed, i.e. + when the user moved the column header \a section from \a fromIndex + to \a toIndex. + + If you want to change the column order programmatically, call + swapRows() or swapColumns(); + + \sa TQHeader::indexChange() rowIndexChanged() +*/ + +void TQTable::columnIndexChanged( int, int fromIndex, int toIndex ) +{ + if ( doSort && lastSortCol == fromIndex && topHeader ) + topHeader->setSortIndicator( toIndex, topHeader->sortIndicatorOrder() ); + repaintContents( contentsX(), contentsY(), + visibleWidth(), visibleHeight(), FALSE ); +} + +/*! + This function is called when the order of the rows is to be + changed, i.e. the user moved the row header section \a section + from \a fromIndex to \a toIndex. + + If you want to change the order programmatically, call swapRows() + or swapColumns(); + + \sa TQHeader::indexChange() columnIndexChanged() +*/ + +void TQTable::rowIndexChanged( int, int, int ) +{ + repaintContents( contentsX(), contentsY(), + visibleWidth(), visibleHeight(), FALSE ); +} + +/*! + This function is called when the column \a col has been clicked. + The default implementation sorts this column if sorting() is TRUE. +*/ + +void TQTable::columnClicked( int col ) +{ + if ( !sorting() ) + return; + + if ( col == lastSortCol ) { + asc = !asc; + } else { + lastSortCol = col; + asc = TRUE; + } + sortColumn( lastSortCol, asc ); +} + +/*! + \property TQTable::sorting + \brief whether a click on the header of a column sorts that column + + \sa sortColumn() +*/ + +void TQTable::setSorting( bool b ) +{ + doSort = b; + if ( topHeader ) + topHeader->setSortIndicator( b ? lastSortCol : -1 ); +} + +bool TQTable::sorting() const +{ + return doSort; +} + +static bool inUpdateGeometries = FALSE; + +void TQTable::delayedUpdateGeometries() +{ + d->geomTimer->start( 0, TRUE ); +} + +void TQTable::updateGeometriesSlot() +{ + updateGeometries(); +} + +/*! + This function updates the geometries of the left and top header. + You do not normally need to call this function. +*/ + +void TQTable::updateGeometries() +{ + if ( inUpdateGeometries ) + return; + inUpdateGeometries = TRUE; + TQSize ts = tableSize(); + if ( topHeader->offset() && + ts.width() < topHeader->offset() + topHeader->width() ) + horizontalScrollBar()->setValue( ts.width() - topHeader->width() ); + if ( leftHeader->offset() && + ts.height() < leftHeader->offset() + leftHeader->height() ) + verticalScrollBar()->setValue( ts.height() - leftHeader->height() ); + + leftHeader->setGeometry( TQStyle::tqvisualRect( TQRect( frameWidth(), topMargin() + frameWidth(), + VERTICALMARGIN, visibleHeight() ), rect() ) ); + topHeader->setGeometry( TQStyle::tqvisualRect( TQRect(VERTICALMARGIN + frameWidth(), frameWidth(), + visibleWidth(), topMargin() ), rect() ) ); + horizontalScrollBar()->raise(); + verticalScrollBar()->raise(); + topHeader->updateStretches(); + leftHeader->updateStretches(); + inUpdateGeometries = FALSE; +} + +/*! + Returns the width of column \a col. + + \sa setColumnWidth() rowHeight() +*/ + +int TQTable::columnWidth( int col ) const +{ + return topHeader->sectionSize( col ); +} + +/*! + Returns the height of row \a row. + + \sa setRowHeight() columnWidth() +*/ + +int TQTable::rowHeight( int row ) const +{ + return leftHeader->sectionSize( row ); +} + +/*! + Returns the x-coordinate of the column \a col in content + coordinates. + + \sa columnAt() rowPos() +*/ + +int TQTable::columnPos( int col ) const +{ + return topHeader->sectionPos( col ); +} + +/*! + Returns the y-coordinate of the row \a row in content coordinates. + + \sa rowAt() columnPos() +*/ + +int TQTable::rowPos( int row ) const +{ + return leftHeader->sectionPos( row ); +} + +/*! + Returns the number of the column at position \a x. \a x must be + given in content coordinates. + + \sa columnPos() rowAt() +*/ + +int TQTable::columnAt( int x ) const +{ + return topHeader->sectionAt( x ); +} + +/*! + Returns the number of the row at position \a y. \a y must be given + in content coordinates. + + \sa rowPos() columnAt() +*/ + +int TQTable::rowAt( int y ) const +{ + return leftHeader->sectionAt( y ); +} + +/*! + Returns the bounding rectangle of the cell at \a row, \a col in + content coordinates. +*/ + +TQRect TQTable::cellGeometry( int row, int col ) const +{ + TQTableItem *itm = item( row, col ); + + if ( !itm || (itm->rowSpan() == 1 && itm->colSpan() == 1) ) + return TQRect( columnPos( col ), rowPos( row ), + columnWidth( col ), rowHeight( row ) ); + + while ( row != itm->row() ) + row--; + while ( col != itm->col() ) + col--; + + TQRect rect( columnPos( col ), rowPos( row ), + columnWidth( col ), rowHeight( row ) ); + + for ( int r = 1; r < itm->rowSpan(); ++r ) + rect.setHeight( rect.height() + rowHeight( r + row ) ); + + for ( int c = 1; c < itm->colSpan(); ++c ) + rect.setWidth( rect.width() + columnWidth( c + col ) ); + + return rect; +} + +/*! + Returns the size of the table. + + This is the same as the coordinates of the bottom-right edge of + the last table cell. +*/ + +TQSize TQTable::tableSize() const +{ + return TQSize( columnPos( numCols() - 1 ) + columnWidth( numCols() - 1 ), + rowPos( numRows() - 1 ) + rowHeight( numRows() - 1 ) ); +} + +/*! + \property TQTable::numRows + \brief The number of rows in the table + + \sa numCols +*/ + +int TQTable::numRows() const +{ + return leftHeader->count(); +} + +/*! + \property TQTable::numCols + \brief The number of columns in the table + + \sa numRows +*/ + +int TQTable::numCols() const +{ + return topHeader->count(); +} + +void TQTable::saveContents( TQPtrVector<TQTableItem> &tmp, + TQPtrVector<TQTable::TableWidget> &tmp2) +{ + int nCols = numCols(); + if ( editRow != -1 && editCol != -1 ) + endEdit( editRow, editCol, FALSE, edMode != Editing ); + tmp.resize( contents.size() ); + tmp2.resize( widgets.size() ); + int i; + for ( i = 0; i < (int)tmp.size(); ++i ) { + TQTableItem *item = contents[ i ]; + if ( item && ( item->row() * nCols) + item->col() == i ) + tmp.insert( i, item ); + else + tmp.insert( i, 0 ); + } + for ( i = 0; i < (int)tmp2.size(); ++i ) { + TQWidget *w = widgets[ i ]; + if ( w ) + tmp2.insert( i, new TableWidget( w, i / nCols, i % nCols ) ); + else + tmp2.insert( i, 0 ); + } +} + +void TQTable::updateHeaderAndResizeContents( TQTableHeader *header, + int num, int rowCol, + int width, bool &updateBefore ) +{ + updateBefore = rowCol < num; + if ( rowCol > num ) { + header->TQHeader::resizeArrays( rowCol ); + header->TQTableHeader::resizeArrays( rowCol ); + int old = num; + clearSelection( FALSE ); + int i = 0; + for ( i = old; i < rowCol; ++i ) + header->addLabel( TQString::null, width ); + } else { + clearSelection( FALSE ); + if ( header == leftHeader ) { + while ( numRows() > rowCol ) + header->removeLabel( numRows() - 1 ); + } else { + while ( numCols() > rowCol ) + header->removeLabel( numCols() - 1 ); + } + } + + contents.setAutoDelete( FALSE ); + contents.clear(); + contents.setAutoDelete( TRUE ); + widgets.setAutoDelete( FALSE ); + widgets.clear(); + widgets.setAutoDelete( TRUE ); + resizeData( numRows() * numCols() ); + + // keep numStretches in sync + int n = 0; + for ( uint i = 0; i < header->stretchable.size(); i++ ) + n += ( header->stretchable.at(i) & 1 ); // avoid cmp + header->numStretches = n; +} + +void TQTable::restoreContents( TQPtrVector<TQTableItem> &tmp, + TQPtrVector<TQTable::TableWidget> &tmp2 ) +{ + int i; + int nCols = numCols(); + for ( i = 0; i < (int)tmp.size(); ++i ) { + TQTableItem *it = tmp[ i ]; + if ( it ) { + int idx = ( it->row() * nCols ) + it->col(); + if ( (uint)idx < contents.size() && + it->row() == idx / nCols && it->col() == idx % nCols ) { + contents.insert( idx, it ); + if ( it->rowSpan() > 1 || it->colSpan() > 1 ) { + int ridx, iidx; + for ( int irow = 0; irow < it->rowSpan(); irow++ ) { + ridx = idx + irow * nCols; + for ( int icol = 0; icol < it->colSpan(); icol++ ) { + iidx = ridx + icol; + if ( idx != iidx && (uint)iidx < contents.size() ) + contents.insert( iidx, it ); + } + } + + } + } else { + delete it; + } + } + } + for ( i = 0; i < (int)tmp2.size(); ++i ) { + TableWidget *w = tmp2[ i ]; + if ( w ) { + int idx = ( w->row * nCols ) + w->col; + if ( (uint)idx < widgets.size() && + w->row == idx / nCols && w->col == idx % nCols ) + widgets.insert( idx, w->wid ); + else + delete w->wid; + delete w; + } + } +} + +void TQTable::finishContentsResze( bool updateBefore ) +{ + TQRect r( cellGeometry( numRows() - 1, numCols() - 1 ) ); + resizeContents( r.right() + 1, r.bottom() + 1 ); + updateGeometries(); + if ( updateBefore ) + repaintContents( contentsX(), contentsY(), + visibleWidth(), visibleHeight(), TRUE ); + else + repaintContents( contentsX(), contentsY(), + visibleWidth(), visibleHeight(), FALSE ); + + if ( isRowSelection( selectionMode() ) ) { + int r = curRow; + curRow = -1; + setCurrentCell( r, curCol ); + } +} + +void TQTable::setNumRows( int r ) +{ + if ( r < 0 ) + return; + + if (r < numRows()) { + // Removed rows are no longer hidden, and should thus be removed from "hiddenRows" + for (int rr = numRows()-1; rr >= r; --rr) { + if (d->hiddenRows.tqfind(rr)) + d->hiddenRows.remove(rr); + } + } + + fontChange(font()); // tqinvalidate the tqsizeHintCache + + TQPtrVector<TQTableItem> tmp; + TQPtrVector<TableWidget> tmp2; + saveContents( tmp, tmp2 ); + + bool isUpdatesEnabled = leftHeader->isUpdatesEnabled(); + leftHeader->setUpdatesEnabled( FALSE ); + + bool updateBefore; + updateHeaderAndResizeContents( leftHeader, numRows(), r, 20, updateBefore ); + + int w = fontMetrics().width( TQString::number( r ) + "W" ); + if ( VERTICALMARGIN > 0 && w > VERTICALMARGIN ) + setLeftMargin( w ); + + restoreContents( tmp, tmp2 ); + + leftHeader->calculatePositions(); + finishContentsResze( updateBefore ); + leftHeader->setUpdatesEnabled( isUpdatesEnabled ); + if ( isUpdatesEnabled ) + leftHeader->update(); + leftHeader->updateCache(); + if ( curRow >= numRows() ) { + curRow = numRows() - 1; + if ( curRow < 0 ) + curCol = -1; + else + repaintCell( curRow, curCol ); + } + + if ( curRow > numRows() ) + curRow = numRows(); +} + +void TQTable::setNumCols( int c ) +{ + if ( c < 0 ) + return; + + if (c < numCols()) { + // Removed columns are no longer hidden, and should thus be removed from "hiddenCols" + for (int cc = numCols()-1; cc >= c; --cc) { + if (d->hiddenCols.tqfind(cc)) + d->hiddenCols.remove(cc); + } + } + + fontChange(font()); // tqinvalidate the tqsizeHintCache + + TQPtrVector<TQTableItem> tmp; + TQPtrVector<TableWidget> tmp2; + saveContents( tmp, tmp2 ); + + bool isUpdatesEnabled = topHeader->isUpdatesEnabled(); + topHeader->setUpdatesEnabled( FALSE ); + + bool updateBefore; + updateHeaderAndResizeContents( topHeader, numCols(), c, 100, updateBefore ); + + restoreContents( tmp, tmp2 ); + + topHeader->calculatePositions(); + finishContentsResze( updateBefore ); + topHeader->setUpdatesEnabled( isUpdatesEnabled ); + if ( isUpdatesEnabled ) + topHeader->update(); + topHeader->updateCache(); + if ( curCol >= numCols() ) { + curCol = numCols() - 1; + if ( curCol < 0 ) + curRow = -1; + else + repaintCell( curRow, curCol ); + } +} + +/*! Sets the section labels of the verticalHeader() to \a labels */ + +void TQTable::setRowLabels( const TQStringList &labels ) +{ + leftHeader->setLabels(labels); +} + +/*! Sets the section labels of the horizontalHeader() to \a labels */ + +void TQTable::setColumnLabels( const TQStringList &labels ) +{ + topHeader->setLabels(labels); +} + +/*! + This function returns the widget which should be used as an editor + for the contents of the cell at \a row, \a col. + + If \a 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 \a initFromCell is FALSE, the content of + the cell is tqreplaced with the new content which the user entered + into the widget created by this function. + + The default functionality is as follows: if \a initFromCell is + TRUE or the cell has a TQTableItem and the table item's + TQTableItem::isReplaceable() is FALSE then the cell is asked to + create an appropriate editor (using TQTableItem::createEditor()). + Otherwise a TQLineEdit is used as the editor. + + If you want to create your own editor for certain cells, implement + a custom TQTableItem subclass and reimplement + TQTableItem::createEditor(). + + If you are not using \l{TQTableItem}s and you don't want to use a + TQLineEdit as the default editor, subclass TQTable and reimplement + this function with code like this: + \code + TQTableItem *i = item( row, col ); + if ( initFromCell || ( i && !i->isReplaceable() ) ) + // If we had a TQTableItem ask the base class to create the editor + return TQTable::createEditor( row, col, initFromCell ); + else + return ...(create your own editor) + \endcode + 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. + + \sa TQTableItem::createEditor() +*/ + +TQWidget *TQTable::createEditor( int row, int col, bool initFromCell ) const +{ + if ( isReadOnly() || isRowReadOnly( row ) || isColumnReadOnly( col ) ) + return 0; + + TQWidget *e = 0; + + // the current item in the cell should be edited if possible + TQTableItem *i = item( row, col ); + if ( initFromCell || ( i && !i->isReplaceable() ) ) { + if ( i ) { + if ( i->editType() == TQTableItem::Never ) + return 0; + + e = i->createEditor(); + if ( !e ) + return 0; + } + } + + // no contents in the cell yet, so open the default editor + if ( !e ) { + e = new TQLineEdit( viewport(), "qt_lineeditor" ); + ( (TQLineEdit*)e )->setFrame( FALSE ); + } + + return e; +} + +/*! + This function is called to start in-place editing of the cell at + \a row, \a 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 tqreplace the cell's content + with the editor's content.) If \a tqreplace 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. + + \sa endEdit() +*/ + +TQWidget *TQTable::beginEdit( int row, int col, bool tqreplace ) +{ + if ( isReadOnly() || isRowReadOnly( row ) || isColumnReadOnly( col ) ) + return 0; + if ( row < 0 || row >= numRows() || col < 0 || col >= numCols() ) + return 0; + + TQTableItem *itm = item( row, col ); + if ( itm && !itm->isEnabled() ) + return 0; + if ( cellWidget( row, col ) ) + return 0; + ensureCellVisible( row, col ); + TQWidget *e = createEditor( row, col, !tqreplace ); + if ( !e ) + return 0; + setCellWidget( row, col, e ); + e->setActiveWindow(); + e->setFocus(); + updateCell( row, col ); + return e; +} + +/*! + This function is called when in-place editing of the cell at \a + row, \a col is requested to stop. + + If the cell is not being edited or \a accept is FALSE the function + returns and the cell's contents are left unchanged. + + If \a accept is TRUE the content of the editor must be transferred + to the relevant cell. If \a tqreplace is TRUE the current content of + this cell should be tqreplaced by the content of the editor (this + means removing the current TQTableItem 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 TQTableItem of this cell. + + setCellContentFromEditor() is called to tqreplace the contents of + the cell with the contents of the cell's editor. + + Finally clearCellWidget() is called to remove the editor widget. + + \sa setCellContentFromEditor(), beginEdit() +*/ + +void TQTable::endEdit( int row, int col, bool accept, bool tqreplace ) +{ + TQWidget *editor = cellWidget( row, col ); + if ( !editor ) + return; + + if ( !accept ) { + if ( row == editRow && col == editCol ) + setEditMode( NotEditing, -1, -1 ); + clearCellWidget( row, col ); + updateCell( row, col ); + viewport()->setFocus(); + updateCell( row, col ); + return; + } + + TQTableItem *i = item( row, col ); + TQString oldContent; + if ( i ) + oldContent = i->text(); + + if ( !i || tqreplace ) { + setCellContentFromEditor( row, col ); + i = item( row, col ); + } else { + i->setContentFromEditor( editor ); + } + + if ( row == editRow && col == editCol ) + setEditMode( NotEditing, -1, -1 ); + + viewport()->setFocus(); + updateCell( row, col ); + + if (!i || (oldContent != i->text())) + emit valueChanged( row, col ); + + clearCellWidget( row, col ); +} + +/*! + This function is called to tqreplace the contents of the cell at \a + row, \a col with the contents of the cell's editor. + + If there already exists a TQTableItem for the cell, + it calls TQTableItem::setContentFromEditor() on this TQTableItem. + + If, for example, you want to create different \l{TQTableItem}s + depending on the contents of the editor, you might reimplement + this function. + + If you want to work without \l{TQTableItem}s, you will need to + reimplement this function to save the data the user entered into + your data structure. (See the notes on large tables.) + + \sa TQTableItem::setContentFromEditor() createEditor() +*/ + +void TQTable::setCellContentFromEditor( int row, int col ) +{ + TQWidget *editor = cellWidget( row, col ); + if ( !editor ) + return; + + TQTableItem *i = item( row, col ); + if ( i ) { + i->setContentFromEditor( editor ); + } else { + TQLineEdit *le = ::tqqt_cast<TQLineEdit*>(editor); + if ( le ) + setText( row, col, le->text() ); + } +} + +/*! + Returns TRUE if the \l EditMode is \c Editing or \c Replacing; + otherwise (i.e. the \l EditMode is \c NotEditing) returns FALSE. + + \sa TQTable::EditMode +*/ + +bool TQTable::isEditing() const +{ + return edMode != NotEditing; +} + +/*! + Returns the current edit mode + + \sa TQTable::EditMode +*/ + +TQTable::EditMode TQTable::editMode() const +{ + return edMode; +} + +/*! + Returns the current edited row +*/ + +int TQTable::currEditRow() const +{ + return editRow; +} + +/*! + Returns the current edited column +*/ + +int TQTable::currEditCol() const +{ + return editCol; +} + +/*! + Returns a single integer which identifies a particular \a row and \a + 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 TQIntDict to map integers to the cells that are used. +*/ + +int TQTable::indexOf( int row, int col ) const +{ + return ( row * numCols() ) + col; +} + +/*! \internal +*/ + +void TQTable::repaintSelections( TQTableSelection *oldSelection, + TQTableSelection *newSelection, + bool updateVertical, bool updateHorizontal ) +{ + if ( !oldSelection && !newSelection ) + return; + if ( oldSelection && newSelection && *oldSelection == *newSelection ) + return; + if ( oldSelection && !oldSelection->isActive() ) + oldSelection = 0; + + bool optimizeOld = FALSE; + bool optimizeNew = FALSE; + + TQRect old; + if ( oldSelection ) + old = rangeGeometry( oldSelection->topRow(), + oldSelection->leftCol(), + oldSelection->bottomRow(), + oldSelection->rightCol(), + optimizeOld ); + else + old = TQRect( 0, 0, 0, 0 ); + + TQRect cur; + if ( newSelection ) + cur = rangeGeometry( newSelection->topRow(), + newSelection->leftCol(), + newSelection->bottomRow(), + newSelection->rightCol(), + optimizeNew ); + else + cur = TQRect( 0, 0, 0, 0 ); + int i; + + if ( !optimizeOld || !optimizeNew || + old.width() > SHRT_MAX || old.height() > SHRT_MAX || + cur.width() > SHRT_MAX || cur.height() > SHRT_MAX ) { + TQRect rr = cur.unite( old ); + repaintContents( rr, FALSE ); + } else { + old = TQRect( contentsToViewport2( old.topLeft() ), old.size() ); + cur = TQRect( contentsToViewport2( cur.topLeft() ), cur.size() ); + TQRegion r1( old ); + TQRegion r2( cur ); + TQRegion r3 = r1.subtract( r2 ); + TQRegion r4 = r2.subtract( r1 ); + + for ( i = 0; i < (int)r3.rects().count(); ++i ) { + TQRect r( r3.rects()[ i ] ); + r = TQRect( viewportToContents2( r.topLeft() ), r.size() ); + repaintContents( r, FALSE ); + } + for ( i = 0; i < (int)r4.rects().count(); ++i ) { + TQRect r( r4.rects()[ i ] ); + r = TQRect( viewportToContents2( r.topLeft() ), r.size() ); + repaintContents( r, FALSE ); + } + } + + int top, left, bottom, right; + { + int oldTopRow = oldSelection ? oldSelection->topRow() : numRows() - 1; + int newTopRow = newSelection ? newSelection->topRow() : numRows() - 1; + top = TQMIN(oldTopRow, newTopRow); + } + + { + int oldLeftCol = oldSelection ? oldSelection->leftCol() : numCols() - 1; + int newLeftCol = newSelection ? newSelection->leftCol() : numCols() - 1; + left = TQMIN(oldLeftCol, newLeftCol); + } + + { + int oldBottomRow = oldSelection ? oldSelection->bottomRow() : 0; + int newBottomRow = newSelection ? newSelection->bottomRow() : 0; + bottom = TQMAX(oldBottomRow, newBottomRow); + } + + { + int oldRightCol = oldSelection ? oldSelection->rightCol() : 0; + int newRightCol = newSelection ? newSelection->rightCol() : 0; + right = TQMAX(oldRightCol, newRightCol); + } + + if ( updateHorizontal && numCols() > 0 && left >= 0 && !isRowSelection( selectionMode() ) ) { + register int *s = &topHeader->states.data()[left]; + for ( i = left; i <= right; ++i ) { + if ( !isColumnSelected( i ) ) + *s = TQTableHeader::Normal; + else if ( isColumnSelected( i, TRUE ) ) + *s = TQTableHeader::Selected; + else + *s = TQTableHeader::Bold; + ++s; + } + topHeader->tqrepaint( FALSE ); + } + + if ( updateVertical && numRows() > 0 && top >= 0 ) { + register int *s = &leftHeader->states.data()[top]; + for ( i = top; i <= bottom; ++i ) { + if ( !isRowSelected( i ) ) + *s = TQTableHeader::Normal; + else if ( isRowSelected( i, TRUE ) ) + *s = TQTableHeader::Selected; + else + *s = TQTableHeader::Bold; + ++s; + } + leftHeader->tqrepaint( FALSE ); + } +} + +/*! + Repaints all selections +*/ + +void TQTable::repaintSelections() +{ + if ( selections.isEmpty() ) + return; + + TQRect r; + for ( TQTableSelection *s = selections.first(); s; s = selections.next() ) { + bool b; + r = r.unite( rangeGeometry( s->topRow(), + s->leftCol(), + s->bottomRow(), + s->rightCol(), b ) ); + } + + repaintContents( r, FALSE ); +} + +/*! + Clears all selections and repaints the appropriate regions if \a + tqrepaint is TRUE. + + \sa removeSelection() +*/ + +void TQTable::clearSelection( bool tqrepaint ) +{ + if ( selections.isEmpty() ) + return; + bool needRepaint = !selections.isEmpty(); + + TQRect r; + for ( TQTableSelection *s = selections.first(); s; s = selections.next() ) { + bool b; + r = r.unite( rangeGeometry( s->topRow(), + s->leftCol(), + s->bottomRow(), + s->rightCol(), b ) ); + } + + currentSel = 0; + selections.clear(); + + if ( needRepaint && tqrepaint ) + repaintContents( r, FALSE ); + + leftHeader->setSectionStateToAll( TQTableHeader::Normal ); + leftHeader->tqrepaint( FALSE ); + if ( !isRowSelection( selectionMode() ) ) { + topHeader->setSectionStateToAll( TQTableHeader::Normal ); + topHeader->tqrepaint( FALSE ); + } + topHeader->setSectionState( curCol, TQTableHeader::Bold ); + leftHeader->setSectionState( curRow, TQTableHeader::Bold ); + emit selectionChanged(); +} + +/*! \internal +*/ + +TQRect TQTable::rangeGeometry( int topRow, int leftCol, + int bottomRow, int rightCol, bool &optimize ) +{ + topRow = TQMAX( topRow, rowAt( contentsY() ) ); + leftCol = TQMAX( leftCol, columnAt( contentsX() ) ); + int ra = rowAt( contentsY() + visibleHeight() ); + if ( ra != -1 ) + bottomRow = TQMIN( bottomRow, ra ); + int ca = columnAt( contentsX() + visibleWidth() ); + if ( ca != -1 ) + rightCol = TQMIN( rightCol, ca ); + optimize = TRUE; + TQRect rect; + for ( int r = topRow; r <= bottomRow; ++r ) { + for ( int c = leftCol; c <= rightCol; ++c ) { + rect = rect.unite( cellGeometry( r, c ) ); + TQTableItem *i = item( r, c ); + if ( i && ( i->rowSpan() > 1 || i->colSpan() > 1 ) ) + optimize = FALSE; + } + } + return rect; +} + +/*! + 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. +*/ + +void TQTable::activateNextCell() +{ + int firstRow = 0; + while ( d->hiddenRows.tqfind( firstRow ) ) + firstRow++; + int firstCol = 0; + while ( d->hiddenCols.tqfind( firstCol ) ) + firstCol++; + int nextRow = curRow; + int nextCol = curCol; + while ( d->hiddenRows.tqfind( ++nextRow ) ); + if ( nextRow >= numRows() ) { + nextRow = firstRow; + while ( d->hiddenCols.tqfind( ++nextCol ) ); + if ( nextCol >= numCols() ) + nextCol = firstCol; + } + + if ( !currentSel || !currentSel->isActive() || + ( currentSel->leftCol() == currentSel->rightCol() && + currentSel->topRow() == currentSel->bottomRow() ) ) { + clearSelection(); + setCurrentCell( nextRow, nextCol ); + } else { + if ( curRow < currentSel->bottomRow() ) + setCurrentCell( nextRow, curCol ); + else if ( curCol < currentSel->rightCol() ) + setCurrentCell( currentSel->topRow(), nextCol ); + else + setCurrentCell( currentSel->topRow(), currentSel->leftCol() ); + } + +} + +/*! \internal +*/ + +void TQTable::fixRow( int &row, int y ) +{ + if ( row == -1 ) { + if ( y < 0 ) + row = 0; + else + row = numRows() - 1; + } +} + +/*! \internal +*/ + +void TQTable::fixCol( int &col, int x ) +{ + if ( col == -1 ) { + if ( x < 0 ) + col = 0; + else + col = numCols() - 1; + } +} + +struct SortableTableItem +{ + TQTableItem *item; +}; + +#if defined(TQ_C_CALLBACKS) +extern "C" { +#endif + +#ifdef TQ_OS_TEMP +static int _cdecl cmpTableItems( const void *n1, const void *n2 ) +#else +static int cmpTableItems( const void *n1, const void *n2 ) +#endif +{ + if ( !n1 || !n2 ) + return 0; + + SortableTableItem *i1 = (SortableTableItem *)n1; + SortableTableItem *i2 = (SortableTableItem *)n2; + + return i1->item->key().localeAwareCompare( i2->item->key() ); +} + +#if defined(TQ_C_CALLBACKS) +} +#endif + +/*! + Sorts column \a col. If \a ascending is TRUE the sort is in + ascending order, otherwise the sort is in descending order. + + If \a 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 TQTableItems you will need to + reimplement swapRows() and swapCells(). (See the notes on large + tables.) + + \sa swapRows() +*/ + +void TQTable::sortColumn( int col, bool ascending, bool wholeRows ) +{ + int filledRows = 0, i; + for ( i = 0; i < numRows(); ++i ) { + TQTableItem *itm = item( i, col ); + if ( itm ) + filledRows++; + } + + if ( !filledRows ) + return; + + SortableTableItem *items = new SortableTableItem[ filledRows ]; + int j = 0; + for ( i = 0; i < numRows(); ++i ) { + TQTableItem *itm = item( i, col ); + if ( !itm ) + continue; + items[ j++ ].item = itm; + } + + qsort( items, filledRows, sizeof( SortableTableItem ), cmpTableItems ); + + bool updatesEnabled = isUpdatesEnabled(); + setUpdatesEnabled( FALSE ); + for ( i = 0; i < numRows(); ++i ) { + if ( i < filledRows ) { + if ( ascending ) { + if ( items[ i ].item->row() == i ) + continue; + if ( wholeRows ) + swapRows( items[ i ].item->row(), i ); + else + swapCells( items[ i ].item->row(), col, i, col ); + } else { + if ( items[ i ].item->row() == filledRows - i - 1 ) + continue; + if ( wholeRows ) + swapRows( items[ i ].item->row(), filledRows - i - 1 ); + else + swapCells( items[ i ].item->row(), col, + filledRows - i - 1, col ); + } + } + } + setUpdatesEnabled( updatesEnabled ); + if ( topHeader ) + topHeader->setSortIndicator( col, ascending ? TQt::Ascending : TQt::Descending ); + + if ( !wholeRows ) + repaintContents( columnPos( col ), contentsY(), + columnWidth( col ), visibleHeight(), FALSE ); + else + repaintContents( contentsX(), contentsY(), + visibleWidth(), visibleHeight(), FALSE ); + + delete [] items; +} + +/*! + Hides row \a row. + + \sa showRow() hideColumn() +*/ + +void TQTable::hideRow( int row ) +{ + if ( d->hiddenRows.tqfind( row ) ) + return; + d->hiddenRows.tqreplace( row, new int( leftHeader->sectionSize( row ) ) ); + leftHeader->resizeSection( row, 0 ); + leftHeader->setResizeEnabled( FALSE, row ); + if ( isRowStretchable(row) ) + leftHeader->numStretches--; + rowHeightChanged( row ); + if ( curRow == row ) { + int r = curRow; + int c = curCol; + int k = ( r >= numRows() - 1 ? Qt::Key_Up : Qt::Key_Down ); + fixCell( r, c, k ); + if ( numRows() > 0 ) + setCurrentCell( r, c ); + } +} + +/*! + Hides column \a col. + + \sa showColumn() hideRow() +*/ + +void TQTable::hideColumn( int col ) +{ + if ( !numCols() || d->hiddenCols.tqfind( col ) ) + return; + d->hiddenCols.tqreplace( col, new int( topHeader->sectionSize( col ) ) ); + topHeader->resizeSection( col, 0 ); + topHeader->setResizeEnabled( FALSE, col ); + if ( isColumnStretchable(col) ) + topHeader->numStretches--; + columnWidthChanged( col ); + if ( curCol == col ) { + int r = curRow; + int c = curCol; + int k = ( c >= numCols() - 1 ? Qt::Key_Left : Qt::Key_Right ); + fixCell( r, c, k ); + if ( numCols() > 0 ) + setCurrentCell( r, c ); + } +} + +/*! + Shows row \a row. + + \sa hideRow() showColumn() +*/ + +void TQTable::showRow( int row ) +{ + int *h = d->hiddenRows.tqfind( row ); + if ( h ) { + int rh = *h; + d->hiddenRows.remove( row ); + setRowHeight( row, rh ); + if ( isRowStretchable(row) ) + leftHeader->numStretches++; + } else if ( rowHeight( row ) == 0 ) { + setRowHeight( row, 20 ); + } + leftHeader->setResizeEnabled( TRUE, row ); +} + +/*! + Shows column \a col. + + \sa hideColumn() showRow() +*/ + +void TQTable::showColumn( int col ) +{ + int *w = d->hiddenCols.tqfind( col ); + if ( w ) { + int cw = *w; + d->hiddenCols.remove( col ); + setColumnWidth( col, cw ); + if ( isColumnStretchable( col ) ) + topHeader->numStretches++; + } else if ( columnWidth( col ) == 0 ) { + setColumnWidth( col, 20 ); + } + topHeader->setResizeEnabled( TRUE, col ); +} + +/*! + Returns TRUE if row \a row is hidden; otherwise returns + FALSE. + + \sa hideRow(), isColumnHidden() +*/ +bool TQTable::isRowHidden( int row ) const +{ + return d->hiddenRows.tqfind( row ); +} + +/*! + Returns TRUE if column \a col is hidden; otherwise returns + FALSE. + + \sa hideColumn(), isRowHidden() +*/ +bool TQTable::isColumnHidden( int col ) const +{ + return d->hiddenCols.tqfind( col ); +} + +/*! + Resizes column \a col to be \a w pixels wide. + + \sa columnWidth() setRowHeight() +*/ + +void TQTable::setColumnWidth( int col, int w ) +{ + int *ow = d->hiddenCols.tqfind( col ); + if ( ow ) { + d->hiddenCols.tqreplace( col, new int( w ) ); + } else { + topHeader->resizeSection( col, w ); + columnWidthChanged( col ); + } +} + +/*! + Resizes row \a row to be \a h pixels high. + + \sa rowHeight() setColumnWidth() +*/ + +void TQTable::setRowHeight( int row, int h ) +{ + int *oh = d->hiddenRows.tqfind( row ); + if ( oh ) { + d->hiddenRows.tqreplace( row, new int( h ) ); + } else { + leftHeader->resizeSection( row, h ); + rowHeightChanged( row ); + } +} + +/*! + Resizes column \a col so that the column width is wide enough to + display the widest item the column tqcontains. + + \sa adjustRow() +*/ + +void TQTable::adjustColumn( int col ) +{ + int w; + if ( currentColumn() == col ) { + TQFont f = font(); + f.setBold(true); + w = topHeader->sectionSizeHint( col, TQFontMetrics(f) ).width(); + } else { + w = topHeader->sectionSizeHint( col, fontMetrics() ).width(); + } + if ( topHeader->iconSet( col ) ) + w += topHeader->iconSet( col )->pixmap().width(); + w = TQMAX( w, 20 ); + for ( int i = 0; i < numRows(); ++i ) { + TQTableItem *itm = item( i, col ); + if ( !itm ) { + TQWidget *widget = cellWidget( i, col ); + if ( widget ) + w = TQMAX( w, widget->tqsizeHint().width() ); + } else { + if ( itm->colSpan() > 1 ) + w = TQMAX( w, itm->tqsizeHint().width() / itm->colSpan() ); + else + w = TQMAX( w, itm->tqsizeHint().width() ); + } + } + w = TQMAX( w, TQApplication::globalStrut().width() ); + setColumnWidth( col, w ); +} + +/*! + Resizes row \a row so that the row height is tall enough to + display the tallest item the row tqcontains. + + \sa adjustColumn() +*/ + +void TQTable::adjustRow( int row ) +{ + int h = 20; + h = TQMAX( h, leftHeader->sectionSizeHint( row, leftHeader->fontMetrics() ).height() ); + if ( leftHeader->iconSet( row ) ) + h = TQMAX( h, leftHeader->iconSet( row )->pixmap().height() ); + for ( int i = 0; i < numCols(); ++i ) { + TQTableItem *itm = item( row, i ); + if ( !itm ) { + TQWidget *widget = cellWidget( row, i ); + if ( widget ) + h = TQMAX( h, widget->tqsizeHint().height() ); + } else { + if ( itm->rowSpan() > 1 ) + h = TQMAX( h, itm->tqsizeHint().height() / itm->rowSpan() ); + else + h = TQMAX( h, itm->tqsizeHint().height() ); + } + } + h = TQMAX( h, TQApplication::globalStrut().height() ); + setRowHeight( row, h ); +} + +/*! + If \a stretch is TRUE, column \a col is set to be stretchable; + otherwise column \a 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. + + \sa isColumnStretchable() setRowStretchable() adjustColumn() +*/ + +void TQTable::setColumnStretchable( int col, bool stretch ) +{ + topHeader->setSectionStretchable( col, stretch ); + + if ( stretch && d->hiddenCols.tqfind(col) ) + topHeader->numStretches--; +} + +/*! + If \a stretch is TRUE, row \a row is set to be stretchable; + otherwise row \a 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. + + \sa isRowStretchable() setColumnStretchable() +*/ + +void TQTable::setRowStretchable( int row, bool stretch ) +{ + leftHeader->setSectionStretchable( row, stretch ); + + if ( stretch && d->hiddenRows.tqfind(row) ) + leftHeader->numStretches--; +} + +/*! + Returns TRUE if column \a col is stretchable; otherwise returns + FALSE. + + \sa setColumnStretchable() isRowStretchable() +*/ + +bool TQTable::isColumnStretchable( int col ) const +{ + return topHeader->isSectionStretchable( col ); +} + +/*! + Returns TRUE if row \a row is stretchable; otherwise returns + FALSE. + + \sa setRowStretchable() isColumnStretchable() +*/ + +bool TQTable::isRowStretchable( int row ) const +{ + return leftHeader->isSectionStretchable( row ); +} + +/*! + Takes the table item \a i out of the table. This function does \e + 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(). +*/ + +void TQTable::takeItem( TQTableItem *i ) +{ + if ( !i ) + return; + TQRect rect = cellGeometry( i->row(), i->col() ); + contents.setAutoDelete( FALSE ); + int bottom = i->row() + i->rowSpan(); + if ( bottom > numRows() ) + bottom = numRows(); + int right = i->col() + i->colSpan(); + if ( right > numCols() ) + right = numCols(); + for ( int r = i->row(); r < bottom; ++r ) { + for ( int c = i->col(); c < right; ++c ) + contents.remove( indexOf( r, c ) ); + } + contents.setAutoDelete( TRUE ); + repaintContents( rect, FALSE ); + int orow = i->row(); + int ocol = i->col(); + i->setRow( -1 ); + i->setCol( -1 ); + i->updateEditor( orow, ocol ); + i->t = 0; +} + +/*! + Sets the widget \a e to the cell at \a row, \a col and takes care of + placing and resizing the widget when the cell tqgeometry 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 \c new operator. The + cell widgets are destroyed automatically once the table is + destroyed; the table takes ownership of the widget when using + setCellWidget. + +*/ + +void TQTable::setCellWidget( int row, int col, TQWidget *e ) +{ + if ( !e || row >= numRows() || col >= numCols() ) + return; + + TQWidget *w = cellWidget( row, col ); + if ( w && row == editRow && col == editCol ) + endEdit( editRow, editCol, FALSE, edMode != Editing ); + + e->installEventFilter( this ); + clearCellWidget( row, col ); + if ( e->tqparent() != TQT_TQOBJECT(viewport()) ) + e->reparent( viewport(), TQPoint( 0,0 ) ); + TQTableItem *itm = item(row, col); + if (itm && itm->row() >= 0 && itm->col() >= 0) { // get the correct row and col if the item is spanning + row = itm->row(); + col = itm->col(); + } + insertWidget( row, col, e ); + TQRect cr = cellGeometry( row, col ); + e->resize( cr.size() ); + moveChild( e, cr.x(), cr.y() ); + e->show(); +} + +/*! + Inserts widget \a w at \a row, \a col into the internal + data structure. See the documentation of setCellWidget() for + further details. + + If you don't use \l{TQTableItem}s you may need to reimplement this + function: see the notes on large tables. +*/ + +void TQTable::insertWidget( int row, int col, TQWidget *w ) +{ + if ( row < 0 || col < 0 || row > numRows() - 1 || col > numCols() - 1 ) + return; + + if ( (int)widgets.size() != numRows() * numCols() ) + widgets.resize( numRows() * numCols() ); + + widgets.insert( indexOf( row, col ), w ); +} + +/*! + Returns the widget that has been set for the cell at \a row, \a + col, or 0 if no widget has been set. + + If you don't use \l{TQTableItem}s you may need to reimplement this + function: see the notes on large tables. + + \sa clearCellWidget() setCellWidget() +*/ + +TQWidget *TQTable::cellWidget( int row, int col ) const +{ + if ( row < 0 || col < 0 || row > numRows() - 1 || col > numCols() - 1 ) + return 0; + + if ( (int)widgets.size() != numRows() * numCols() ) + ( (TQTable*)this )->widgets.resize( numRows() * numCols() ); + + return widgets[ indexOf( row, col ) ]; +} + +/*! + Removes the widget (if there is one) set for the cell at \a row, + \a col. + + If you don't use \l{TQTableItem}s you may need to reimplement this + function: see the notes on large tables. + + This function deletes the widget at \a row, \a col. Note that the + widget is not deleted immediately; instead TQObject::deleteLater() + is called on the widget to avoid problems with timing issues. + + \sa cellWidget() setCellWidget() +*/ + +void TQTable::clearCellWidget( int row, int col ) +{ + if ( row < 0 || col < 0 || row > numRows() - 1 || col > numCols() - 1 ) + return; + + if ( (int)widgets.size() != numRows() * numCols() ) + widgets.resize( numRows() * numCols() ); + + TQWidget *w = cellWidget( row, col ); + if ( w ) { + w->removeEventFilter( this ); + w->deleteLater(); + } + widgets.setAutoDelete( FALSE ); + widgets.remove( indexOf( row, col ) ); + widgets.setAutoDelete( TRUE ); +} + +/*! + \fn void TQTable::dropped ( TQDropEvent * e ) + + This signal is emitted when a drop event occurred on the table. + + \a e tqcontains information about the drop. +*/ + +/*! + If \a b is TRUE, the table starts a drag (see dragObject()) when + the user presses and moves the mouse on a selected cell. +*/ + +void TQTable::setDragEnabled( bool b ) +{ + dEnabled = b; +} + +/*! + If this function returns TRUE, the table supports dragging. + + \sa setDragEnabled(); +*/ + +bool TQTable::dragEnabled() const +{ + return dEnabled; +} + +/*! + Inserts \a count empty rows at row \a row. Also clears the selection(s). + + \sa insertColumns() removeRow() +*/ + +void TQTable::insertRows( int row, int count ) +{ + // special case, so a call like insertRow( currentRow(), 1 ) also + // works, when we have 0 rows and currentRow() is -1 + if ( row == -1 && curRow == -1 ) + row = 0; + if ( row < 0 || count <= 0 ) + return; + + if ( curRow >= row && curRow < row + count ) + curRow = row + count; + + --row; + if ( row >= numRows() ) + return; + + bool updatesEnabled = isUpdatesEnabled(); + setUpdatesEnabled( FALSE ); + bool leftHeaderUpdatesEnabled = leftHeader->isUpdatesEnabled(); + leftHeader->setUpdatesEnabled( FALSE ); + int oldLeftMargin = leftMargin(); + + setNumRows( numRows() + count ); + + for ( int i = numRows() - count - 1; i > row; --i ) + leftHeader->swapSections( i, i + count ); + + leftHeader->setUpdatesEnabled( leftHeaderUpdatesEnabled ); + setUpdatesEnabled( updatesEnabled ); + + int cr = TQMAX( 0, currentRow() ); + int cc = TQMAX( 0, currentColumn() ); + if ( curRow > row ) + curRow -= count; // this is where curRow was + setCurrentCell( cr, cc, TRUE, FALSE ); // without ensureCellVisible + + // Repaint the header + if ( leftHeaderUpdatesEnabled ) { + int y = rowPos( row ) - contentsY(); + if ( leftMargin() != oldLeftMargin || d->hasRowSpan ) + y = 0; // full tqrepaint + TQRect rect( 0, y, leftHeader->width(), contentsHeight() ); + leftHeader->update( rect ); + } + + if ( updatesEnabled ) { + int p = rowPos( row ); + if ( d->hasRowSpan ) + p = contentsY(); + updateContents( contentsX(), p, visibleWidth(), contentsHeight() + 1 ); + } +} + +/*! + Inserts \a count empty columns at column \a col. Also clears the selection(s). + + \sa insertRows() removeColumn() +*/ + +void TQTable::insertColumns( int col, int count ) +{ + // see comment in insertRows() + if ( col == -1 && curCol == -1 ) + col = 0; + if ( col < 0 || count <= 0 ) + return; + + if ( curCol >= col && curCol < col + count ) + curCol = col + count; + + --col; + if ( col >= numCols() ) + return; + + bool updatesEnabled = isUpdatesEnabled(); + setUpdatesEnabled( FALSE ); + bool topHeaderUpdatesEnabled = topHeader->isUpdatesEnabled(); + topHeader->setUpdatesEnabled( FALSE ); + int oldTopMargin = topMargin(); + + setNumCols( numCols() + count ); + + for ( int i = numCols() - count - 1; i > col; --i ) + topHeader->swapSections( i, i + count ); + + topHeader->setUpdatesEnabled( topHeaderUpdatesEnabled ); + setUpdatesEnabled( updatesEnabled ); + + int cr = TQMAX( 0, currentRow() ); + int cc = TQMAX( 0, currentColumn() ); + if ( curCol > col ) + curCol -= count; // this is where curCol was + setCurrentCell( cr, cc, TRUE, FALSE ); // without ensureCellVisible + + // Repaint the header + if ( topHeaderUpdatesEnabled ) { + int x = columnPos( col ) - contentsX(); + if ( topMargin() != oldTopMargin || d->hasColSpan ) + x = 0; // full tqrepaint + TQRect rect( x, 0, contentsWidth(), topHeader->height() ); + topHeader->update( rect ); + } + + if ( updatesEnabled ) { + int p = columnPos( col ); + if ( d->hasColSpan ) + p = contentsX(); + updateContents( p, contentsY(), contentsWidth() + 1, visibleHeight() ); + } +} + +/*! + Removes row \a row, and deletes all its cells including any table + items and widgets the cells may contain. Also clears the selection(s). + + \sa hideRow() insertRows() removeColumn() removeRows() +*/ + +void TQTable::removeRow( int row ) +{ + if ( row < 0 || row >= numRows() ) + return; + if ( row < numRows() - 1 ) { + if (d->hiddenRows.tqfind(row)) + d->hiddenRows.remove(row); + + for ( int i = row; i < numRows() - 1; ++i ) + ( (TQTableHeader*)verticalHeader() )->swapSections( i, i + 1 ); + } + setNumRows( numRows() - 1 ); +} + +/*! + Removes the rows listed in the array \a 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). + + \sa removeRow() insertRows() removeColumns() +*/ + +void TQTable::removeRows( const TQMemArray<int> &rows ) +{ + if ( rows.count() == 0 ) + return; + int i; + for ( i = 0; i < (int)rows.count() - 1; ++i ) { + for ( int j = rows[i] - i; j < rows[i + 1] - i - 1; j++ ) { + ( (TQTableHeader*)verticalHeader() )->swapSections( j, j + i + 1 ); + } + } + + for ( int j = rows[i] - i; j < numRows() - (int)rows.size(); j++) + ( (TQTableHeader*)verticalHeader() )->swapSections( j, j + rows.count() ); + + setNumRows( numRows() - rows.count() ); +} + +/*! + Removes column \a col, and deletes all its cells including any + table items and widgets the cells may contain. Also clears the + selection(s). + + \sa removeColumns() hideColumn() insertColumns() removeRow() +*/ + +void TQTable::removeColumn( int col ) +{ + if ( col < 0 || col >= numCols() ) + return; + if ( col < numCols() - 1 ) { + if (d->hiddenCols.tqfind(col)) + d->hiddenCols.remove(col); + + for ( int i = col; i < numCols() - 1; ++i ) + ( (TQTableHeader*)horizontalHeader() )->swapSections( i, i + 1 ); + } + setNumCols( numCols() - 1 ); +} + +/*! + Removes the columns listed in the array \a 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). + + \sa removeColumn() insertColumns() removeRows() +*/ + +void TQTable::removeColumns( const TQMemArray<int> &cols ) +{ + if ( cols.count() == 0 ) + return; + int i; + for ( i = 0; i < (int)cols.count() - 1; ++i ) { + for ( int j = cols[i] - i; j < cols[i + 1] - i - 1; j++ ) { + ( (TQTableHeader*)horizontalHeader() )->swapSections( j, j + i + 1 ); + } + } + + for ( int j = cols[i] - i; j < numCols() - (int)cols.size(); j++) + ( (TQTableHeader*)horizontalHeader() )->swapSections( j, j + cols.count() ); + + setNumCols( numCols() - cols.count() ); +} + +/*! + Starts editing the cell at \a row, \a col. + + If \a tqreplace is TRUE the content of this cell will be tqreplaced 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. + + \sa beginEdit() +*/ + +void TQTable::editCell( int row, int col, bool tqreplace ) +{ + if ( row < 0 || col < 0 || row > numRows() - 1 || col > numCols() - 1 ) + return; + + if ( beginEdit( row, col, tqreplace ) ) { + edMode = Editing; + editRow = row; + editCol = col; + } +} + +#ifndef TQT_NO_DRAGANDDROP + +/*! + This event handler is called whenever a TQTable object receives a + \l TQDragEnterEvent \a e, i.e. when the user pressed the mouse + button to drag something. + + The focus is moved to the cell where the TQDragEnterEvent occurred. +*/ + +void TQTable::contentsDragEnterEvent( TQDragEnterEvent *e ) +{ + oldCurrentRow = curRow; + oldCurrentCol = curCol; + int tmpRow = rowAt( e->pos().y() ); + int tmpCol = columnAt( e->pos().x() ); + fixRow( tmpRow, e->pos().y() ); + fixCol( tmpCol, e->pos().x() ); + if (TQT_TQOBJECT(e->source()) != (TQObject*)cellWidget( currentRow(), currentColumn() ) ) + setCurrentCell( tmpRow, tmpCol, FALSE, TRUE ); + e->accept(); +} + +/*! + This event handler is called whenever a TQTable object receives a + \l TQDragMoveEvent \a e, i.e. when the user actually drags the + mouse. + + The focus is moved to the cell where the TQDragMoveEvent occurred. +*/ + +void TQTable::contentsDragMoveEvent( TQDragMoveEvent *e ) +{ + int tmpRow = rowAt( e->pos().y() ); + int tmpCol = columnAt( e->pos().x() ); + fixRow( tmpRow, e->pos().y() ); + fixCol( tmpCol, e->pos().x() ); + if (TQT_TQOBJECT(e->source()) != (TQObject*)cellWidget( currentRow(), currentColumn() ) ) + setCurrentCell( tmpRow, tmpCol, FALSE, TRUE ); + e->accept(); +} + +/*! + This event handler is called when a drag activity leaves \e this + TQTable object with event \a e. +*/ + +void TQTable::contentsDragLeaveEvent( TQDragLeaveEvent * ) +{ + setCurrentCell( oldCurrentRow, oldCurrentCol, FALSE, TRUE ); +} + +/*! + This event handler is called when the user ends a drag and drop by + dropping something onto \e this TQTable and thus triggers the drop + event, \a e. +*/ + +void TQTable::contentsDropEvent( TQDropEvent *e ) +{ + setCurrentCell( oldCurrentRow, oldCurrentCol, FALSE, TRUE ); + emit dropped( e ); +} + +/*! + 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 TQDragObject depending on the selected items. + + \sa dropped() +*/ + +TQDragObject *TQTable::dragObject() +{ + return 0; +} + +/*! + Starts a drag. + + Usually you don't need to call or reimplement this function yourself. + + \sa dragObject(); +*/ + +void TQTable::startDrag() +{ + if ( startDragRow == -1 || startDragCol == -1 ) + return; + + startDragRow = startDragCol = -1; + + TQDragObject *drag = dragObject(); + if ( !drag ) + return; + + drag->drag(); +} + +#endif + +/*! \reimp */ +void TQTable::windowActivationChange( bool oldActive ) +{ + if ( oldActive && autoScrollTimer ) + autoScrollTimer->stop(); + + if ( !isVisible() ) + return; + + if ( tqpalette().active() != tqpalette().inactive() ) + updateContents(); +} + +/*! \reimp */ +void TQTable::setEnabled( bool b ) +{ + if ( !b ) { + // editor will lose focus, causing a crash deep in setEnabled(), + // so we'll end the edit early. + endEdit( editRow, editCol, TRUE, edMode != Editing ); + } + TQScrollView::setEnabled(b); +} + + +/* + \class TQTableHeader + \brief The TQTableHeader class allows for creation and manipulation + of table headers. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup advanced + \module table + + + TQTable uses this subclass of TQHeader for its headers. TQTable has a + horizontalHeader() for displaying column labels, and a + verticalHeader() for displaying row labels. + +*/ + +/* + \enum TQTableHeader::SectionState + + This enum type denotes the state of the header's text + + \value Normal the default + \value Bold + \value Selected typically represented by showing the section "sunken" + or "pressed in" +*/ + +/*! + Creates a new table header called \a name with \a i sections. It + is a child of widget \a tqparent and attached to table \a t. +*/ + +TQTableHeader::TQTableHeader( int i, TQTable *t, + TQWidget *tqparent, const char *name ) + : TQHeader( i, tqparent, name ), mousePressed(FALSE), startPos(-1), + table( t ), caching( FALSE ), resizedSection(-1), + numStretches( 0 ) +{ + setIsATableHeader( TRUE ); + d = 0; + states.resize( i ); + stretchable.resize( i ); + states.fill( Normal, -1 ); + stretchable.fill( FALSE, -1 ); + autoScrollTimer = new TQTimer( this ); + connect( autoScrollTimer, TQT_SIGNAL( timeout() ), + this, TQT_SLOT( doAutoScroll() ) ); +#ifndef NO_LINE_WIDGET + line1 = new TQWidget( table->viewport(), "qt_line1" ); + line1->hide(); + line1->setBackgroundMode( TQt::PaletteText ); + table->addChild( line1 ); + line2 = new TQWidget( table->viewport(), "qt_line2" ); + line2->hide(); + line2->setBackgroundMode( TQt::PaletteText ); + table->addChild( line2 ); +#else + d = new TQTableHeaderPrivate; + d->oldLinePos = -1; //outside, in contents coords +#endif + connect( this, TQT_SIGNAL( sizeChange(int,int,int) ), + this, TQT_SLOT( sectionWidthChanged(int,int,int) ) ); + connect( this, TQT_SIGNAL( indexChange(int,int,int) ), + this, TQT_SLOT( indexChanged(int,int,int) ) ); + + stretchTimer = new TQTimer( this ); + widgetStretchTimer = new TQTimer( this ); + connect( stretchTimer, TQT_SIGNAL( timeout() ), + this, TQT_SLOT( updateStretches() ) ); + connect( widgetStretchTimer, TQT_SIGNAL( timeout() ), + this, TQT_SLOT( updateWidgetStretches() ) ); + startPos = -1; +} + +/*! + Adds a new section, \a size pixels wide (or high for vertical + headers) with the label \a s. If \a size is negative the section's + size is calculated based on the width (or height) of the label's + text. +*/ + +void TQTableHeader::addLabel( const TQString &s , int size ) +{ + TQHeader::addLabel( s, size ); + if ( count() > (int)states.size() ) { + int s = states.size(); + states.resize( count() ); + stretchable.resize( count() ); + for ( ; s < count(); ++s ) { + states[ s ] = Normal; + stretchable[ s ] = FALSE; + } + } +} + +void TQTableHeader::removeLabel( int section ) +{ + TQHeader::removeLabel( section ); + if ( section == (int)states.size() - 1 ) { + states.resize( states.size() - 1 ); + stretchable.resize( stretchable.size() - 1 ); + } +} + +void TQTableHeader::resizeArrays( int n ) +{ + int old = states.size(); + states.resize( n ); + stretchable.resize( n ); + if ( n > old ) { + for ( int i = old; i < n; ++i ) { + stretchable[ i ] = FALSE; + states[ i ] = Normal; + } + } +} + +void TQTableHeader::setLabel( int section, const TQString & s, int size ) +{ + TQHeader::setLabel( section, s, size ); + sectionLabelChanged( section ); +} + +void TQTableHeader::setLabel( int section, const TQIconSet & iconset, + const TQString & s, int size ) +{ + TQHeader::setLabel( section, iconset, s, size ); + sectionLabelChanged( section ); +} + +/*! + Sets the SectionState of section \a s to \a astate. + + \sa sectionState() +*/ + +void TQTableHeader::setSectionState( int s, SectionState astate ) +{ + if ( s < 0 || s >= (int)states.count() ) + return; + if ( states.data()[ s ] == astate ) + return; + if ( isRowSelection( table->selectionMode() ) && orientation() == Qt::Horizontal ) + return; + + states.data()[ s ] = astate; + if ( isUpdatesEnabled() ) { + if ( orientation() == Qt::Horizontal ) + tqrepaint( sectionPos( s ) - offset(), 0, sectionSize( s ), height(), FALSE ); + else + tqrepaint( 0, sectionPos( s ) - offset(), width(), sectionSize( s ), FALSE ); + } +} + +void TQTableHeader::setSectionStateToAll( SectionState state ) +{ + if ( isRowSelection( table->selectionMode() ) && orientation() == Qt::Horizontal ) + return; + + register int *d = (int *) states.data(); + int n = count(); + + while (n >= 4) { + d[0] = state; + d[1] = state; + d[2] = state; + d[3] = state; + d += 4; + n -= 4; + } + + if (n > 0) { + d[0] = state; + if (n > 1) { + d[1] = state; + if (n > 2) { + d[2] = state; + } + } + } +} + +/*! + Returns the SectionState of section \a s. + + \sa setSectionState() +*/ + +TQTableHeader::SectionState TQTableHeader::sectionState( int s ) const +{ + return (s < 0 || s >= (int)states.count() ? Normal : (TQTableHeader::SectionState)states[s]); +} + +/*! \reimp +*/ + +void TQTableHeader::paintEvent( TQPaintEvent *e ) +{ + TQPainter p( this ); + p.setPen( tqcolorGroup().buttonText() ); + int pos = orientation() == Qt::Horizontal + ? e->rect().left() + : e->rect().top(); + int id = mapToIndex( sectionAt( pos + offset() ) ); + if ( id < 0 ) { + if ( pos > 0 ) + return; + else + id = 0; + } + + TQRegion reg = e->region(); + for ( int i = id; i < count(); i++ ) { + TQRect r = sRect( i ); + reg -= r; + p.save(); + if ( !( orientation() == Qt::Horizontal && isRowSelection( table->selectionMode() ) ) && + ( sectionState( i ) == Bold || sectionState( i ) == Selected ) ) { + TQFont f( font() ); + f.setBold( TRUE ); + p.setFont( f ); + } + paintSection( &p, i, r ); + p.restore(); + if ( (orientation() == Qt::Horizontal && r. right() >= e->rect().right()) || + (orientation() == Qt::Vertical && r. bottom() >= e->rect().bottom()) ) + return; + } + if ( !reg.isEmpty() ) + erase( reg ); +} + +/*! + \reimp + + Paints the header section with index \a index into the rectangular + region \a fr on the painter \a p. +*/ + +void TQTableHeader::paintSection( TQPainter *p, int index, const TQRect& fr ) +{ + int section = mapToSection( index ); + if ( section < 0 || cellSize( section ) <= 0 ) + return; + + if ( sectionState( index ) != Selected || + (orientation() == Qt::Horizontal && isRowSelection( table->selectionMode() )) ) { + TQHeader::paintSection( p, index, fr ); + } else { + TQStyle::SFlags flags = TQStyle::Style_Off | ( orient == Qt::Horizontal ? TQStyle::Style_Horizontal : (TQStyle::SFlags)0 ); + if(isEnabled()) + flags |= TQStyle::Style_Enabled; + if(isClickEnabled()) { + if(sectionState(index) == Selected) { + flags |= TQStyle::Style_Down; + if(!mousePressed) + flags |= TQStyle::Style_Sunken; + } + } + if(!(flags & TQStyle::Style_Down)) + flags |= TQStyle::Style_Raised; + tqstyle().tqdrawPrimitive( TQStyle::PE_HeaderSection, p, TQRect(fr.x(), fr.y(), fr.width(), fr.height()), + tqcolorGroup(), flags ); + paintSectionLabel( p, index, fr ); + } +} + +static int real_pos( const TQPoint &p, TQt::Orientation o ) +{ + if ( o == Qt::Horizontal ) + return p.x(); + return p.y(); +} + +/*! \reimp +*/ + +void TQTableHeader::mousePressEvent( TQMouseEvent *e ) +{ + if ( e->button() != Qt::LeftButton ) + return; + TQHeader::mousePressEvent( e ); + mousePressed = TRUE; + pressPos = real_pos( e->pos(), orientation() ); + if ( !table->currentSel || ( e->state() & ShiftButton ) != ShiftButton ) + startPos = -1; + setCaching( TRUE ); + resizedSection = -1; +#ifdef TQT_NO_CURSOR + isResizing = FALSE; +#else + isResizing = cursor().shape() != ArrowCursor; + if ( !isResizing && sectionAt( pressPos ) != -1 ) + doSelection( e ); +#endif +} + +/*! \reimp +*/ + +void TQTableHeader::mouseMoveEvent( TQMouseEvent *e ) +{ + if ( (e->state() & Qt::MouseButtonMask) != Qt::LeftButton // Using LeftButton simulates old behavior. +#ifndef TQT_NO_CURSOR + || cursor().shape() != Qt::ArrowCursor +#endif + || ( ( e->state() & ControlButton ) == ControlButton && + ( orientation() == Qt::Horizontal + ? table->columnMovingEnabled() : table->rowMovingEnabled() ) ) ) { + TQHeader::mouseMoveEvent( e ); + return; + } + + if ( !doSelection( e ) ) + TQHeader::mouseMoveEvent( e ); +} + +bool TQTableHeader::doSelection( TQMouseEvent *e ) +{ + int p = real_pos( e->pos(), orientation() ) + offset(); + + if ( isRowSelection( table->selectionMode() ) ) { + if ( orientation() == Qt::Horizontal ) + return TRUE; + if ( table->selectionMode() == TQTable::SingleRow ) { + int secAt = sectionAt( p ); + if ( secAt == -1 ) + return TRUE; + table->setCurrentCell( secAt, table->currentColumn() ); + return TRUE; + } + } + + if ( startPos == -1 ) { + int secAt = sectionAt( p ); + if ( (( e->state() & ControlButton ) != ControlButton && + ( e->state() & ShiftButton ) != ShiftButton) || + table->selectionMode() == TQTable::Single || + table->selectionMode() == TQTable::SingleRow ) { + startPos = p; + bool b = table->tqsignalsBlocked(); + table->blockSignals( TRUE ); + table->clearSelection(); + table->blockSignals( b ); + } + saveStates(); + + if ( table->selectionMode() != TQTable::NoSelection ) { + startPos = p; + TQTableSelection *oldSelection = table->currentSel; + + if ( orientation() == Qt::Vertical ) { + if ( !table->isRowSelected( secAt, TRUE ) ) { + table->currentSel = new TQTableSelection(); + table->selections.append( table->currentSel ); + table->currentSel->init( secAt, 0 ); + table->currentSel->expandTo( secAt, table->numCols() - 1 ); + emit table->selectionChanged(); + } + table->setCurrentCell( secAt, 0 ); + } else { // orientation == Qt::Horizontal + if ( !table->isColumnSelected( secAt, TRUE ) ) { + table->currentSel = new TQTableSelection(); + table->selections.append( table->currentSel ); + table->currentSel->init( 0, secAt ); + table->currentSel->expandTo( table->numRows() - 1, secAt ); + emit table->selectionChanged(); + } + table->setCurrentCell( 0, secAt ); + } + + if ( (orientation() == Qt::Horizontal && table->isColumnSelected(secAt)) || + (orientation() == Qt::Vertical && table->isRowSelected(secAt))) { + setSectionState( secAt, Selected ); + } + + table->repaintSelections( oldSelection, table->currentSel, + orientation() == Qt::Horizontal, + orientation() == Qt::Vertical ); + if ( sectionAt( p ) != -1 ) + endPos = p; + + return TRUE; + } + } + + if ( sectionAt( p ) != -1 ) + endPos = p; + if ( startPos != -1 ) { + updateSelections(); + p -= offset(); + if ( orientation() == Qt::Horizontal && ( p < 0 || p > width() ) ) { + doAutoScroll(); + autoScrollTimer->start( 100, TRUE ); + } else if ( orientation() == Qt::Vertical && ( p < 0 || p > height() ) ) { + doAutoScroll(); + autoScrollTimer->start( 100, TRUE ); + } + return TRUE; + } + return table->selectionMode() == TQTable::NoSelection; +} + +static inline bool mayOverwriteMargin( int before, int after ) +{ + /* + 0 is the only user value that we always respect. We also never + shrink a margin, in case the user wanted it that way. + */ + return before != 0 && before < after; +} + +void TQTableHeader::sectionLabelChanged( int section ) +{ + emit sectionSizeChanged( section ); + + // this does not really belong here + if ( orientation() == Qt::Horizontal ) { + int h = tqsizeHint().height(); + if ( h != height() && mayOverwriteMargin(table->topMargin(), h) ) + table->setTopMargin( h ); + } else { + int w = tqsizeHint().width(); + if ( w != width() && mayOverwriteMargin( ( TQApplication::reverseLayout() ? table->rightMargin() : table->leftMargin() ), w) ) + table->setLeftMargin( w ); + } +} + +/*! \reimp */ +void TQTableHeader::mouseReleaseEvent( TQMouseEvent *e ) +{ + if ( e->button() != Qt::LeftButton ) + return; + autoScrollTimer->stop(); + mousePressed = FALSE; + setCaching( FALSE ); + TQHeader::mouseReleaseEvent( e ); +#ifndef NO_LINE_WIDGET + line1->hide(); + line2->hide(); +#else + if ( d->oldLinePos >= 0 ) + if ( orientation() == Qt::Horizontal ) + table->updateContents( d->oldLinePos, table->contentsY(), + 1, table->visibleHeight() ); + else + table->updateContents( table->contentsX(), d->oldLinePos, + table->visibleWidth(), 1 ); + d->oldLinePos = -1; +#endif + if ( resizedSection != -1 ) { + emit sectionSizeChanged( resizedSection ); + updateStretches(); + } + + //Make sure all newly selected sections are painted one last time + TQRect selectedRects; + for ( int i = 0; i < count(); i++ ) { + if(sectionState( i ) == Selected) + selectedRects |= sRect( i ); + } + if(!selectedRects.isNull()) + tqrepaint(selectedRects); +} + +/*! \reimp +*/ + +void TQTableHeader::mouseDoubleClickEvent( TQMouseEvent *e ) +{ + if ( e->button() != Qt::LeftButton ) + return; + if ( isResizing ) { + int p = real_pos( e->pos(), orientation() ) + offset(); + int section = sectionAt( p ); + if ( section == -1 ) + return; + section--; + if ( p >= sectionPos( count() - 1 ) + sectionSize( count() - 1 ) ) + ++section; + while ( sectionSize( section ) == 0 ) + section--; + if ( section < 0 ) + return; + int oldSize = sectionSize( section ); + if ( orientation() == Qt::Horizontal ) { + table->adjustColumn( section ); + int newSize = sectionSize( section ); + if ( oldSize != newSize ) + emit sizeChange( section, oldSize, newSize ); + for ( int i = 0; i < table->numCols(); ++i ) { + if ( table->isColumnSelected( i ) && sectionSize( i ) != 0 ) + table->adjustColumn( i ); + } + } else { + table->adjustRow( section ); + int newSize = sectionSize( section ); + if ( oldSize != newSize ) + emit sizeChange( section, oldSize, newSize ); + for ( int i = 0; i < table->numRows(); ++i ) { + if ( table->isRowSelected( i ) && sectionSize( i ) != 0 ) + table->adjustRow( i ); + } + } + } +} + +/*! \reimp +*/ + +void TQTableHeader::resizeEvent( TQResizeEvent *e ) +{ + stretchTimer->stop(); + widgetStretchTimer->stop(); + TQHeader::resizeEvent( e ); + if ( numStretches == 0 ) + return; + stretchTimer->start( 0, TRUE ); +} + +void TQTableHeader::updateStretches() +{ + if ( numStretches == 0 ) + return; + + int dim = orientation() == Qt::Horizontal ? width() : height(); + if ( sectionPos(count() - 1) + sectionSize(count() - 1) == dim ) + return; + int i; + int pd = dim - ( sectionPos(count() - 1) + + sectionSize(count() - 1) ); + bool block = tqsignalsBlocked(); + blockSignals( TRUE ); + for ( i = 0; i < (int)stretchable.count(); ++i ) { + if ( !stretchable[i] || + ( stretchable[i] && table->d->hiddenCols[i] ) ) + continue; + pd += sectionSize( i ); + } + pd /= numStretches; + for ( i = 0; i < (int)stretchable.count(); ++i ) { + if ( !stretchable[i] || + ( stretchable[i] && table->d->hiddenCols[i] ) ) + continue; + if ( i == (int)stretchable.count() - 1 && + sectionPos( i ) + pd < dim ) + pd = dim - sectionPos( i ); + resizeSection( i, TQMAX( 20, pd ) ); + } + blockSignals( block ); + table->repaintContents( FALSE ); + widgetStretchTimer->start( 100, TRUE ); +} + +void TQTableHeader::updateWidgetStretches() +{ + TQSize s = table->tableSize(); + table->resizeContents( s.width(), s.height() ); + for ( int i = 0; i < table->numCols(); ++i ) + table->updateColWidgets( i ); +} + +void TQTableHeader::updateSelections() +{ + if ( table->selectionMode() == TQTable::NoSelection || + (isRowSelection( table->selectionMode() ) && orientation() != Qt::Vertical ) ) + return; + int a = sectionAt( startPos ); + int b = sectionAt( endPos ); + int start = TQMIN( a, b ); + int end = TQMAX( a, b ); + register int *s = states.data(); + for ( int i = 0; i < count(); ++i ) { + if ( i < start || i > end ) + *s = oldStates.data()[ i ]; + else + *s = Selected; + ++s; + } + tqrepaint( FALSE ); + + if (table->currentSel) { + TQTableSelection oldSelection = *table->currentSel; + if ( orientation() == Qt::Vertical ) + table->currentSel->expandTo( b, table->horizontalHeader()->count() - 1 ); + else + table->currentSel->expandTo( table->verticalHeader()->count() - 1, b ); + table->repaintSelections( &oldSelection, table->currentSel, + orientation() == Qt::Horizontal, + orientation() == Qt::Vertical ); + } + emit table->selectionChanged(); +} + +void TQTableHeader::saveStates() +{ + oldStates.resize( count() ); + register int *s = states.data(); + register int *s2 = oldStates.data(); + for ( int i = 0; i < count(); ++i ) { + *s2 = *s; + ++s2; + ++s; + } +} + +void TQTableHeader::doAutoScroll() +{ + TQPoint pos = mapFromGlobal( TQCursor::pos() ); + int p = real_pos( pos, orientation() ) + offset(); + if ( sectionAt( p ) != -1 ) + endPos = p; + if ( orientation() == Qt::Horizontal ) + table->ensureVisible( endPos, table->contentsY() ); + else + table->ensureVisible( table->contentsX(), endPos ); + updateSelections(); + autoScrollTimer->start( 100, TRUE ); +} + +void TQTableHeader::sectionWidthChanged( int col, int, int ) +{ + resizedSection = col; + if ( orientation() == Qt::Horizontal ) { +#ifndef NO_LINE_WIDGET + table->moveChild( line1, TQHeader::sectionPos( col ) - 1, + table->contentsY() ); + line1->resize( 1, table->visibleHeight() ); + line1->show(); + line1->raise(); + table->moveChild( line2, + TQHeader::sectionPos( col ) + TQHeader::sectionSize( col ) - 1, + table->contentsY() ); + line2->resize( 1, table->visibleHeight() ); + line2->show(); + line2->raise(); +#else + TQPainter p( table->viewport() ); + int lx = TQHeader::sectionPos( col ) + TQHeader::sectionSize( col ) - 1; + int ly = table->contentsY(); + + if ( lx != d->oldLinePos ) { + TQPoint pt = table->contentsToViewport( TQPoint( lx, ly ) ); + p.drawLine( pt.x(), pt.y()+1, + pt.x(), pt.y()+ table->visibleHeight() ); + if ( d->oldLinePos >= 0 ) + table->repaintContents( d->oldLinePos, table->contentsY(), + 1, table->visibleHeight() ); + + d->oldLinePos = lx; + } +#endif + } else { +#ifndef NO_LINE_WIDGET + table->moveChild( line1, table->contentsX(), + TQHeader::sectionPos( col ) - 1 ); + line1->resize( table->visibleWidth(), 1 ); + line1->show(); + line1->raise(); + table->moveChild( line2, table->contentsX(), + TQHeader::sectionPos( col ) + TQHeader::sectionSize( col ) - 1 ); + line2->resize( table->visibleWidth(), 1 ); + line2->show(); + line2->raise(); + +#else + TQPainter p( table->viewport() ); + int lx = table->contentsX(); + int ly = TQHeader::sectionPos( col ) + TQHeader::sectionSize( col ) - 1; + + if ( ly != d->oldLinePos ) { + TQPoint pt = table->contentsToViewport( TQPoint( lx, ly ) ); + p.drawLine( pt.x()+1, pt.y(), + pt.x() + table->visibleWidth(), pt.y() ); + if ( d->oldLinePos >= 0 ) + table->repaintContents( table->contentsX(), d->oldLinePos, + table->visibleWidth(), 1 ); + d->oldLinePos = ly; + } + +#endif + } +} + +/*! + \reimp + + Returns the size of section \a section in pixels or -1 if \a + section is out of range. +*/ + +int TQTableHeader::sectionSize( int section ) const +{ + if ( count() <= 0 || section < 0 || section >= count() ) + return -1; + if ( caching && section < (int)sectionSizes.count() ) + return sectionSizes[ section ]; + return TQHeader::sectionSize( section ); +} + +/*! + \reimp + + Returns the start position of section \a section in pixels or -1 + if \a section is out of range. + + \sa sectionAt() +*/ + +int TQTableHeader::sectionPos( int section ) const +{ + if ( count() <= 0 || section < 0 || section >= count() ) + return -1; + if ( caching && section < (int)sectionPoses.count() ) + return sectionPoses[ section ]; + return TQHeader::sectionPos( section ); +} + +/*! + \reimp + + Returns the number of the section at index position \a pos or -1 + if there is no section at the position given. + + \sa sectionPos() +*/ + +int TQTableHeader::sectionAt( int pos ) const +{ + if ( !caching || sectionSizes.count() <= 0 || sectionPoses.count() <= 0 ) + return TQHeader::sectionAt( pos ); + if ( count() <= 0 || pos > sectionPoses[ count() - 1 ] + sectionSizes[ count() - 1 ] ) + return -1; + int l = 0; + int r = count() - 1; + int i = ( (l+r+1) / 2 ); + while ( r - l ) { + if ( sectionPoses[i] > pos ) + r = i -1; + else + l = i; + i = ( (l+r+1) / 2 ); + } + if ( sectionPoses[i] <= pos && + pos <= sectionPoses[i] + sectionSizes[ mapToSection( i ) ] ) + return mapToSection( i ); + return -1; +} + +void TQTableHeader::updateCache() +{ + sectionPoses.resize( count() ); + sectionSizes.resize( count() ); + if ( !caching ) + return; + for ( int i = 0; i < count(); ++i ) { + sectionSizes[ i ] = TQHeader::sectionSize( i ); + sectionPoses[ i ] = TQHeader::sectionPos( i ); + } +} + +void TQTableHeader::setCaching( bool b ) +{ + if ( caching == b ) + return; + caching = b; + sectionPoses.resize( count() ); + sectionSizes.resize( count() ); + if ( b ) { + for ( int i = 0; i < count(); ++i ) { + sectionSizes[ i ] = TQHeader::sectionSize( i ); + sectionPoses[ i ] = TQHeader::sectionPos( i ); + } + } +} + +/*! + If \a b is TRUE, section \a s is stretchable; otherwise the + section is not stretchable. + + \sa isSectionStretchable() +*/ + +void TQTableHeader::setSectionStretchable( int s, bool b ) +{ + if ( stretchable[ s ] == b ) + return; + stretchable[ s ] = b; + if ( b ) + numStretches++; + else + numStretches--; +} + +/*! + Returns TRUE if section \a s is stretcheable; otherwise returns + FALSE. + + \sa setSectionStretchable() +*/ + +bool TQTableHeader::isSectionStretchable( int s ) const +{ + return stretchable[ s ]; +} + +void TQTableHeader::swapSections( int oldIdx, int newIdx, bool swapTable ) +{ + extern bool qt_qheader_label_return_null_strings; // qheader.cpp + qt_qheader_label_return_null_strings = TRUE; + + TQIconSet oldIconSet, newIconSet; + if ( iconSet( oldIdx ) ) + oldIconSet = *iconSet( oldIdx ); + if ( iconSet( newIdx ) ) + newIconSet = *iconSet( newIdx ); + TQString oldLabel = label( oldIdx ); + TQString newLabel = label( newIdx ); + bool sectionsHasContent = !(oldIconSet.isNull() && newIconSet.isNull() + && oldLabel.isNull() && newLabel.isNull()); + if (sectionsHasContent) { + setLabel( oldIdx, newIconSet, newLabel ); + setLabel( newIdx, oldIconSet, oldLabel ); + } + + qt_qheader_label_return_null_strings = FALSE; + + int w1 = sectionSize( oldIdx ); + int w2 = sectionSize( newIdx ); + if ( w1 != w2 ) { + resizeSection( oldIdx, w2 ); + resizeSection( newIdx, w1 ); + } + + if ( !swapTable ) + return; + if ( orientation() == Qt::Horizontal ) + table->swapColumns( oldIdx, newIdx ); + else + table->swapRows( oldIdx, newIdx ); +} + +void TQTableHeader::indexChanged( int sec, int oldIdx, int newIdx ) +{ + newIdx = mapToIndex( sec ); + if ( oldIdx > newIdx ) + moveSection( sec, oldIdx + 1 ); + else + moveSection( sec, oldIdx ); + + if ( oldIdx < newIdx ) { + while ( oldIdx < newIdx ) { + swapSections( oldIdx, oldIdx + 1 ); + oldIdx++; + } + } else { + while ( oldIdx > newIdx ) { + swapSections( oldIdx - 1, oldIdx ); + oldIdx--; + } + } + + table->repaintContents( table->contentsX(), table->contentsY(), + table->visibleWidth(), table->visibleHeight() ); +} + +void TQTableHeader::setLabels(const TQStringList & labels) +{ + int i = 0; + bool updates = isUpdatesEnabled(); + const int c = TQMIN(count(), (int)labels.count()); + setUpdatesEnabled(FALSE); + for ( TQStringList::ConstIterator it = labels.begin(); i < c; ++i, ++it ) { + if (i == c - 1) { + setUpdatesEnabled(updates); + setLabel( i, *it ); + } else { + TQHeader::setLabel( i, *it ); + emit sectionSizeChanged( i ); + } + } +} + +#include "tqtable.tqmoc" + +#endif // TQT_NO_TABLE |