diff options
Diffstat (limited to 'src/qt3support/itemviews/q3table.cpp')
| -rw-r--r-- | src/qt3support/itemviews/q3table.cpp | 7334 |
1 files changed, 7334 insertions, 0 deletions
diff --git a/src/qt3support/itemviews/q3table.cpp b/src/qt3support/itemviews/q3table.cpp new file mode 100644 index 0000000..8295e4e --- /dev/null +++ b/src/qt3support/itemviews/q3table.cpp @@ -0,0 +1,7334 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt3Support module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qglobal.h" +#if defined(Q_CC_BOR) +// needed for qsort() because of a std namespace problem on Borland +#include "qplatformdefs.h" +#endif + +#include "q3table.h" + + +#include <qpainter.h> +#include <qlineedit.h> +#include <qcursor.h> +#include <qapplication.h> +#include <qtimer.h> +#include <qicon.h> +#include <q3combobox.h> +#include <qstyleoption.h> +#include <qcheckbox.h> +#include <q3dragobject.h> +#include <qevent.h> +#include <q3listbox.h> +#include <qstyle.h> +#include <q3datatable.h> +#include <qvalidator.h> +#include <q3button.h> + +#include <stdlib.h> +#include <limits.h> + +QT_BEGIN_NAMESPACE + +using namespace Qt; + +class Q3HeaderData; +extern bool qt_get_null_label_bit(Q3HeaderData *data, int section); +extern void qt_set_null_label_bit(Q3HeaderData *data, int section, bool b); + +static bool qt_update_cell_widget = true; +static bool qt_table_clipper_enabled = true; +#ifndef QT_INTERNAL_TABLE +Q_COMPAT_EXPORT +#endif +void qt_set_table_clipper_enabled(bool enabled) +{ + qt_table_clipper_enabled = enabled; +} + +class Q_COMPAT_EXPORT Q3TableHeader : public Q3Header +{ + friend class Q3Table; + Q_OBJECT + +public: + enum SectionState { + Normal, + Bold, + Selected + }; + + Q3TableHeader(int, Q3Table *t, QWidget* parent=0, const char* name=0); + ~Q3TableHeader() {}; + void addLabel(const QString &s, int size); + void setLabel(int section, const QString & s, int size = -1); + void setLabel(int section, const QIconSet & iconset, const QString & s, + int size = -1); + + void setLabels(const QStringList & 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(); + +signals: + void sectionSizeChanged(int s); + +protected: + void paintEvent(QPaintEvent *e); + void paintSection(QPainter *p, int index, const QRect& fr); + void mousePressEvent(QMouseEvent *e); + void mouseMoveEvent(QMouseEvent *e); + void mouseReleaseEvent(QMouseEvent *e); + void mouseDoubleClickEvent(QMouseEvent *e); + void resizeEvent(QResizeEvent *e); + +private 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(QMouseEvent *e); + void sectionLabelChanged(int section); + void resizeArrays(int n); + +private: + Q3MemArray<int> states, oldStates; + Q3MemArray<bool> stretchable; + Q3MemArray<int> sectionSizes, sectionPoses; + bool mousePressed; + int pressPos, startPos, endPos; + Q3Table *table; + QTimer *autoScrollTimer; + QWidget *line1, *line2; + bool caching; + int resizedSection; + bool isResizing; + int numStretches; + QTimer *stretchTimer, *widgetStretchTimer; + Q3TableHeaderPrivate *d; + + Q_DISABLE_COPY(Q3TableHeader) +}; + +#ifdef _WS_QWS_ +# define NO_LINE_WIDGET +#endif + + + +struct Q3TablePrivate +{ + Q3TablePrivate() : 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; + Q3IntDict<int> hiddenRows, hiddenCols; + QTimer *geomTimer; + int lastVisRow; + int lastVisCol; +}; + +struct Q3TableHeaderPrivate +{ +#ifdef NO_LINE_WIDGET + int oldLinePos; +#endif +}; + +static bool isRowSelection(Q3Table::SelectionMode selMode) +{ + return selMode == Q3Table::SingleRow || selMode == Q3Table::MultiRow; +} + +/*! + \class Q3TableSelection + \brief The Q3TableSelection class provides access to a selected area in a + Q3Table. + + \compat + + The selection is a rectangular set of cells in a Q3Table. 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 find 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 Q3TableSelection is inactive -- isActive() returns + false. You must use init() and expandTo() to activate it. + + \sa Q3Table Q3Table::addSelection() Q3Table::selection() + Q3Table::selectCells() Q3Table::selectRow() Q3Table::selectColumn() +*/ + +/*! + Creates an inactive selection. Use init() and expandTo() to + activate it. +*/ + +Q3TableSelection::Q3TableSelection() + : 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. +*/ + +Q3TableSelection::Q3TableSelection(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 Q3TableSelection::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 Q3TableSelection::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 Q3TableSelection::operator==(const Q3TableSelection &s) const +{ + return (s.active == active && + s.tRow == tRow && s.bRow == bRow && + s.lCol == lCol && s.rCol == rCol); +} + +/*! + \fn bool Q3TableSelection::operator!=(const Q3TableSelection &s) const + + Returns true if \a s does not include the same cells as the + selection; otherwise returns false. +*/ + + +/*! + \fn int Q3TableSelection::topRow() const + + Returns the top row of the selection. + + \sa bottomRow() leftCol() rightCol() +*/ + +/*! + \fn int Q3TableSelection::bottomRow() const + + Returns the bottom row of the selection. + + \sa topRow() leftCol() rightCol() +*/ + +/*! + \fn int Q3TableSelection::leftCol() const + + Returns the left column of the selection. + + \sa topRow() bottomRow() rightCol() +*/ + +/*! + \fn int Q3TableSelection::rightCol() const + + Returns the right column of the selection. + + \sa topRow() bottomRow() leftCol() +*/ + +/*! + \fn int Q3TableSelection::anchorRow() const + + Returns the anchor row of the selection. + + \sa anchorCol() expandTo() +*/ + +/*! + \fn int Q3TableSelection::anchorCol() const + + Returns the anchor column of the selection. + + \sa anchorRow() expandTo() +*/ + +/*! + \fn int Q3TableSelection::numRows() const + + Returns the number of rows in the selection. + + \sa numCols() +*/ +int Q3TableSelection::numRows() const +{ + return (tRow < 0) ? 0 : bRow - tRow + 1; +} + +/*! + Returns the number of columns in the selection. + + \sa numRows() +*/ +int Q3TableSelection::numCols() const +{ + return (lCol < 0) ? 0 : rCol - lCol + 1; +} + +/*! + \fn bool Q3TableSelection::isActive() const + + Returns whether the selection is active or not. A selection is + active after init() \e and expandTo() have been called. +*/ + +/*! + \fn bool Q3TableSelection::isEmpty() const + + Returns whether the selection is empty or not. + + \sa numRows(), numCols() +*/ + +/*! + \class Q3TableItem + \brief The Q3TableItem class provides the cell content for Q3Table cells. + + \compat + + For many applications Q3TableItems are ideal for presenting and + editing the contents of Q3Table cells. In situations where you need + to create very large tables you may prefer an alternative approach + to using Q3TableItems: see the notes on large tables. + + A Q3TableItem contains a cell's data, by default, a string and a + pixmap. The table item also holds the cell's display size and how + the data should be aligned. The table item specifies the cell's + \l EditType and the editor used for in-place editing (by default a + QLineEdit). If you want checkboxes use \l{Q3CheckTableItem}, and if + you want comboboxes use \l{Q3ComboTableItem}. 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 Q3Table::setItem(). If + you insert an item into a cell that already contains a table item + the original item will be deleted. + + Example: + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3table.cpp 0 + + You can move a table item from one cell to another, in the same or + a different table, using Q3Table::takeItem() and Q3Table::setItem() + but see also Q3Table::swapCells(). + + Table items can be deleted with delete in the standard way; the + table and cell will be updated accordingly. + + Note, that if you have a table item that is not currently in a table + then anything you do to that item other than insert it into a table + will result in undefined behaviour. + + Reimplement createEditor() and setContentFromEditor() if you want + to use your own widget instead of a QLineEdit for editing cell + contents. Reimplement paint() if you want to display custom + content. + + It is important to ensure that your custom widget can accept the + keyboard focus, so that the user can use the tab key to navigate the + table as normal. Therefore, if the widget returned by createEditor() + does not itself accept the keyboard focus, it is necessary to + nominate a child widget to do so on its behalf. For example, a + QHBox with two child QLineEdit widgets may use one of them to + accept the keyboard focus: + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3table.cpp 1 + + By default, table items may be replaced by new Q3TableItems + during the lifetime of a Q3Table. Therefore, if you create your + own subclass of Q3TableItem, 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 Q3CheckTableItem Q3ComboTableItem + +*/ + +/*! + \fn Q3Table *Q3TableItem::table() const + + Returns the Q3Table the table item belongs to. + + \sa Q3Table::setItem() Q3TableItem() +*/ + +/*! + \enum Q3TableItem::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 QLineEdit) is always visible. This + has implications for the alignment of the content: the default + editor aligns everything (even numbers) to the left whilst + numerical values in the cell are by default aligned to the right. + + If a cell with the edit type \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 + Q3Table::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 Q3TableItem objects + are created by the convenience functions Q3Table::setText() and + Q3Table::setPixmap(). + + \value Never The cell is not editable. + + The cell is actually editable only if Q3Table::isRowReadOnly() is + false for its row, Q3Table::isColumnReadOnly() is false for its + column, and Q3Table::isReadOnly() is false. + + Q3ComboTableItems 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. + Q3ComboTableItems 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 QLineEdit for its editor, will not + word-wrap and will occupy a single cell. Insert the table item + into a table with Q3Table::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. +*/ + +Q3TableItem::Q3TableItem(Q3Table *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 QLineEdit for its editor, will not + word-wrap and will occupy a single cell. Insert the table item + into a table with Q3Table::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. +*/ + +Q3TableItem::Q3TableItem(Q3Table *table, EditType et, const QString &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 QLineEdit for editing the text, will not word-wrap and + will occupy a single cell. Insert the table item into a table with + Q3Table::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. +*/ + +Q3TableItem::Q3TableItem(Q3Table *table, EditType et, + const QString &text, const QPixmap &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. +*/ + +Q3TableItem::~Q3TableItem() +{ + if (table()) + table()->takeItem(this); +} + +int Q3TableItem::RTTI = 0; + +/*! + Returns the Run Time Type Identification value for this table item + which for Q3TableItems is 0. + + When you create subclasses based on Q3TableItem 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 Q3CheckTableItem::rtti() Q3ComboTableItem::rtti() +*/ + +int Q3TableItem::rtti() const +{ + return RTTI; +} + +/*! + Returns the table item's pixmap or a null pixmap if no pixmap has + been set. + + \sa setPixmap() text() +*/ + +QPixmap Q3TableItem::pixmap() const +{ + return pix; +} + + +/*! + Returns the text of the table item or an empty string 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 QLineEdit. + \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() +*/ + +QString Q3TableItem::text() const +{ + QWidget *w = table()->cellWidget(rw, cl); + if (w && (edType == Always || + rtti() == Q3ComboTableItem::RTTI || + rtti() == Q3CheckTableItem::RTTI)) + ((Q3TableItem*)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 Q3Table::updateCell() to repaint the cell's + contents. + + For \l{Q3ComboTableItem}s and \l{Q3CheckTableItem}s this function + has no visible effect. + + \sa Q3Table::setPixmap() pixmap() setText() +*/ + +void Q3TableItem::setPixmap(const QPixmap &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 Q3Table::updateCell() to repaint the cell's + contents. + + \sa Q3Table::setText() text() setPixmap() Q3Table::updateCell() +*/ + +void Q3TableItem::setText(const QString &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 + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3table.cpp 2 + +*/ + +void Q3TableItem::paint(QPainter *p, const QColorGroup &cg, + const QRect &cr, bool selected) +{ + p->fillRect(0, 0, cr.width(), cr.height(), + selected ? cg.brush(QColorGroup::Highlight) + : cg.brush(QColorGroup::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 ? (alignment() | WordBreak) : alignment(), text()); +} + +/*! +This virtual function creates an editor which the user can +interact with to edit the cell's contents. The default +implementation creates a QLineEdit. + +If the function returns 0, the cell is read-only. + +The returned widget should preferably be invisible, ideally with +Q3Table::viewport() as parent. + +If you reimplement this function you'll almost certainly need to +reimplement setContentFromEditor(), and may need to reimplement +sizeHint(). + +\sa Q3Table::createEditor() setContentFromEditor() Q3Table::viewport() setReplaceable() +*/ + +QWidget *Q3TableItem::createEditor() const +{ + QLineEdit *e = new QLineEdit(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, +Q3Table calls this virtual function to copy the new values into the +Q3TableItem. + +If you reimplement createEditor() and return something that is not +a QLineEdit you will need to reimplement this function. + +\sa Q3Table::setCellContentFromEditor() +*/ + +void Q3TableItem::setContentFromEditor(QWidget *w) +{ + QLineEdit *le = qobject_cast<QLineEdit*>(w); + if (le) { + QString input = le->text(); + if (le->validator()) + le->validator()->fixup(input); + setText(input); + } +} + +/*! + The alignment function returns how the text contents of the cell + are aligned when drawn. The default implementation aligns numbers + to the right and any other text to the left. + + \sa Qt::Alignment +*/ + +// ed: For consistency reasons a setAlignment() should be provided +// as well. + +int Q3TableItem::alignment() 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() Q3Table::adjustColumn() Q3Table::setColumnStretchable() +*/ + +void Q3TableItem::setWordWrap(bool b) +{ + wordwrap = b; +} + +/*! + Returns true if word wrap is enabled for the cell; otherwise + returns false. + + \sa setWordWrap() +*/ + +bool Q3TableItem::wordWrap() const +{ + return wordwrap; +} + +/*! \internal */ + +void Q3TableItem::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 Q3TableItem() +*/ + +Q3TableItem::EditType Q3TableItem::editType() const +{ + return edType; +} + +/*! + If \a b is true it is acceptable to replace the contents of the + cell with the contents of another Q3TableItem. If \a b is false the + contents of the cell may not be replaced by the contents of + another table item. Table items that span more than one cell may + not have their contents replaced by another table item. + + (This differs from \l EditType because EditType is concerned with + whether the \e user is able to change the contents of a cell.) + + \sa isReplaceable() +*/ + +void Q3TableItem::setReplaceable(bool b) +{ + tcha = b; +} + +/*! + This function returns whether the contents of the cell may be + replaced with the contents of another table item. Regardless of + this setting, table items that span more than one cell may not + have their contents replaced by another table item. + + (This differs from \l EditType because EditType is concerned with + whether the \e user is able to change the contents of a cell.) + + \sa setReplaceable() EditType +*/ + +bool Q3TableItem::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 Q3Table::setSorting() +*/ + +QString Q3TableItem::key() const +{ + return text(); +} + +/*! + This virtual function returns the size a cell needs to show its + entire content. + + If you subclass Q3TableItem you will often need to reimplement this + function. +*/ + +QSize Q3TableItem::sizeHint() const +{ + QSize strutSize = QApplication::globalStrut(); + if (edType == Always && table()->cellWidget(rw, cl)) + return table()->cellWidget(rw, cl)->sizeHint().expandedTo(strutSize); + + QSize s; + int x = 0; + if (!pix.isNull()) { + s = pix.size(); + s.setWidth(s.width() + 2); + x = pix.width() + 2; + } + + QString t = text(); + if (!wordwrap && t.find(QLatin1Char('\n')) == -1) + return QSize(s.width() + table()->fontMetrics().width(text()) + 10, + QMAX(s.height(), table()->fontMetrics().height())).expandedTo(strutSize); + + QRect r = table()->fontMetrics().boundingRect(x + 2, 0, table()->columnWidth(col()) - x - 4, 0, + wordwrap ? (alignment() | WordBreak) : alignment(), + text()); + r.setWidth(QMAX(r.width() + 10, table()->columnWidth(col()))); + return QSize(r.width(), QMAX(s.height(), r.height())).expandedTo(strutSize); +} + +/*! + Changes the extent of the Q3TableItem 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. Q3Table::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 Q3TableItems spanning more than one cell is not + supported. + + \sa rowSpan() colSpan() +*/ + +void Q3TableItem::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) { + Q3Table* 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); + QWidget *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 Q3TableItem::rowSpan() const +{ + return rowspan; +} + +/*! + Returns the column span of the table item, usually 1. + + \sa setSpan() rowSpan() +*/ + +int Q3TableItem::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 Q3TableItem::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 Q3TableItem::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 Q3TableItem::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 Q3TableItem::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 Q3TableItem::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 Q3TableItem::isEnabled() const +{ + return (bool)enabled; +} + +/*! + \class Q3ComboTableItem + \brief The Q3ComboTableItem class provides a means of using + comboboxes in Q3Tables. + + \compat + + A Q3ComboTableItem is a table item which looks and behaves like a + combobox. The advantage of using Q3ComboTableItems rather than real + comboboxes is that a Q3ComboTableItem uses far less resources than + real comboboxes in \l{Q3Table}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 + Q3ComboTableItems. + + Q3ComboTableItem items have the edit type \c WhenCurrent (see + \l{EditType}). The Q3ComboTableItem's list of items is provided by + a QStringList 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 Q3ComboTableItem 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 Q3ComboTableItem use + Q3Table::setItem(). + + Q3ComboTableItems may be deleted with Q3Table::clearCell(). + + Q3ComboTableItems can be distinguished from \l{Q3TableItem}s and + \l{Q3CheckTableItem}s using their Run Time Type Identification + number (see rtti()). + + \img qtableitems.png Table Items + + \sa Q3CheckTableItem Q3TableItem Q3ComboBox +*/ + +Q3ComboBox *Q3ComboTableItem::fakeCombo = 0; +QWidget *Q3ComboTableItem::fakeComboWidget = 0; +int Q3ComboTableItem::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 Q3ComboTableItems cannot be replaced by other table + items since isReplaceable() returns false by default. + + \sa Q3Table::clearCell() EditType +*/ + +Q3ComboTableItem::Q3ComboTableItem(Q3Table *table, const QStringList &list, bool editable) + : Q3TableItem(table, WhenCurrent, QLatin1String("")), entries(list), current(0), edit(editable) +{ + setReplaceable(false); + if (!Q3ComboTableItem::fakeCombo) { + Q3ComboTableItem::fakeComboWidget = new QWidget(0, 0); + Q3ComboTableItem::fakeCombo = new Q3ComboBox(false, Q3ComboTableItem::fakeComboWidget, 0); + Q3ComboTableItem::fakeCombo->hide(); + } + ++Q3ComboTableItem::fakeRef; + if (entries.count()) + setText(entries.at(current)); +} + +/*! + Q3ComboTableItem destructor. +*/ +Q3ComboTableItem::~Q3ComboTableItem() +{ + if (--Q3ComboTableItem::fakeRef <= 0) { + delete Q3ComboTableItem::fakeComboWidget; + Q3ComboTableItem::fakeComboWidget = 0; + Q3ComboTableItem::fakeCombo = 0; + } +} + +/*! + Sets the list items of this Q3ComboTableItem to the strings in the + string list \a l. +*/ + +void Q3ComboTableItem::setStringList(const QStringList &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 */ + +QWidget *Q3ComboTableItem::createEditor() const +{ + // create an editor - a combobox in our case + ((Q3ComboTableItem*)this)->cb = new Q3ComboBox(edit, table()->viewport(), "qt_editor_cb"); + cb->insertStringList(entries); + cb->setCurrentItem(current); + QObject::connect(cb, SIGNAL(activated(int)), table(), SLOT(doValueChanged())); + return cb; +} + +/*! \reimp */ + +void Q3ComboTableItem::setContentFromEditor(QWidget *w) +{ + Q3ComboBox *cb = qobject_cast<Q3ComboBox*>(w); + if (cb) { + entries.clear(); + for (int i = 0; i < cb->count(); ++i) + entries << cb->text(i); + current = cb->currentItem(); + setText(cb->currentText()); + } +} + +/*! \reimp */ + +void Q3ComboTableItem::paint(QPainter *p, const QColorGroup &cg, + const QRect &cr, bool selected) +{ + fakeCombo->resize(cr.width(), cr.height()); + + QPalette pal2(cg); + if (selected) { + pal2.setBrush(QPalette::Base, cg.QPalette::brush(QPalette::Highlight)); + pal2.setColor(QPalette::Text, cg.highlightedText()); + } + + QStyle::State flags = QStyle::State_None; + if(isEnabled() && table()->isEnabled()) + flags |= QStyle::State_Enabled; + // Since we still have the "fakeCombo" may as well use it in this case. + QStyleOptionComboBox opt; + opt.initFrom(table()); + opt.rect = fakeCombo->rect(); + opt.palette = pal2; + opt.state &= ~QStyle::State_HasFocus; + opt.state &= ~QStyle::State_MouseOver; + opt.state |= flags; + opt.subControls = QStyle::SC_All; + opt.activeSubControls = QStyle::SC_None; + opt.editable = fakeCombo->editable(); + table()->style()->drawComplexControl(QStyle::CC_ComboBox, &opt, p, fakeCombo); + + p->save(); + QRect textR = table()->style()->subControlRect(QStyle::CC_ComboBox, &opt, + QStyle::SC_ComboBoxEditField, fakeCombo); + int align = alignment(); // alignment() changes entries + p->drawText(textR, wordWrap() ? (align | Qt::WordBreak) : align, entries.value(current)); + p->restore(); +} + +/*! + Sets the list item \a i to be the combo table item's current list + item. + + \sa currentItem() +*/ + +void Q3ComboTableItem::setCurrentItem(int i) +{ + QWidget *w = table()->cellWidget(row(), col()); + Q3ComboBox *cb = qobject_cast<Q3ComboBox*>(w); + if (cb) { + cb->setCurrentItem(i); + current = cb->currentItem(); + setText(cb->currentText()); + } else { + if (i < 0 || i >= entries.count()) + return; + 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 Q3ComboTableItem::setCurrentItem(const QString &s) +{ + int i = entries.findIndex(s); + if (i != -1) + setCurrentItem(i); +} + +/*! + Returns the index of the combo table item's current list item. + + \sa setCurrentItem() +*/ + +int Q3ComboTableItem::currentItem() const +{ + QWidget *w = table()->cellWidget(row(), col()); + Q3ComboBox *cb = qobject_cast<Q3ComboBox*>(w); + if (cb) + return cb->currentItem(); + return current; +} + +/*! + Returns the text of the combo table item's current list item. + + \sa currentItem() text() +*/ + +QString Q3ComboTableItem::currentText() const +{ + QWidget *w = table()->cellWidget(row(), col()); + Q3ComboBox *cb = qobject_cast<Q3ComboBox*>(w); + if (cb) + return cb->currentText(); + return entries.value(current); +} + +/*! + Returns the total number of list items in the combo table item. +*/ + +int Q3ComboTableItem::count() const +{ + QWidget *w = table()->cellWidget(row(), col()); + Q3ComboBox *cb = qobject_cast<Q3ComboBox*>(w); + if (cb) + return cb->count(); + return (int)entries.count(); +} + +/*! + Returns the text of the combo's list item at index \a i. + + \sa currentText() +*/ + +QString Q3ComboTableItem::text(int i) const +{ + QWidget *w = table()->cellWidget(row(), col()); + Q3ComboBox *cb = qobject_cast<Q3ComboBox*>(w); + if (cb) + return cb->text(i); + return entries.value(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 Q3ComboTableItem::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 Q3ComboTableItem::isEditable() const +{ + return edit; +} + +int Q3ComboTableItem::RTTI = 1; + +/*! + \fn int Q3ComboTableItem::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 Q3TableItem::rtti() +*/ + +int Q3ComboTableItem::rtti() const +{ + return RTTI; +} + +/*! \reimp */ + +QSize Q3ComboTableItem::sizeHint() const +{ + fakeCombo->insertItem(currentText()); + fakeCombo->setCurrentItem(fakeCombo->count() - 1); + QSize sh = fakeCombo->sizeHint(); + fakeCombo->removeItem(fakeCombo->count() - 1); + return sh.expandedTo(QApplication::globalStrut()); +} + +/*! + \fn QString Q3ComboTableItem::text() const + + Returns the text of the table item or an empty string if there is + no text. + + \sa Q3TableItem::text() +*/ + +/*! + \class Q3CheckTableItem + \brief The Q3CheckTableItem class provides checkboxes in Q3Tables. + + \compat + + A Q3CheckTableItem is a table item which looks and behaves like a + checkbox. The advantage of using Q3CheckTableItems rather than real + checkboxes is that a Q3CheckTableItem uses far less resources than + a real checkbox would in a \l{Q3Table}. 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 Q3CheckTableItems. + + Q3CheckTableItem 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 Q3CheckTableItem use + Q3Table::setItem(). + + Q3CheckTableItems can be distinguished from \l{Q3TableItem}s and + \l{Q3ComboTableItem}s using their Run Time Type Identification + (rtti) value. + + \img qtableitems.png Table Items + + \sa rtti() EditType Q3ComboTableItem Q3TableItem QCheckBox +*/ + +/*! + Creates a Q3CheckTableItem 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. +*/ + +Q3CheckTableItem::Q3CheckTableItem(Q3Table *table, const QString &txt) + : Q3TableItem(table, WhenCurrent, txt), checked(false) +{ +} + +/*! \reimp */ + +void Q3CheckTableItem::setText(const QString &t) +{ + Q3TableItem::setText(t); + QWidget *w = table()->cellWidget(row(), col()); + QCheckBox *cb = qobject_cast<QCheckBox*>(w); + if (cb) + cb->setText(t); +} + + +/*! \reimp */ + +QWidget *Q3CheckTableItem::createEditor() const +{ + // create an editor - a combobox in our case + ((Q3CheckTableItem*)this)->cb = new QCheckBox(table()->viewport(), "qt_editor_checkbox"); + cb->setChecked(checked); + cb->setText(text()); + cb->setBackgroundColor(table()->viewport()->backgroundColor()); + cb->setAutoFillBackground(true); + QObject::connect(cb, SIGNAL(toggled(bool)), table(), SLOT(doValueChanged())); + return cb; +} + +/*! \reimp */ + +void Q3CheckTableItem::setContentFromEditor(QWidget *w) +{ + QCheckBox *cb = qobject_cast<QCheckBox*>(w); + if (cb) + checked = cb->isChecked(); +} + +/*! \reimp */ + +void Q3CheckTableItem::paint(QPainter *p, const QColorGroup &cg, + const QRect &cr, bool selected) +{ + QPalette pal = cg; + + p->fillRect(0, 0, cr.width(), cr.height(), + selected ? pal.brush(QPalette::Highlight) + : pal.brush(QPalette::Base)); + + QSize sz = QSize(table()->style()->pixelMetric(QStyle::PM_IndicatorWidth), + table()->style()->pixelMetric(QStyle::PM_IndicatorHeight)); + QPalette pal2(pal); + pal2.setBrush(QPalette::Window, pal.brush(QPalette::Base)); + QStyleOptionButton opt; + opt.initFrom(table()); + opt.rect.setRect(0, (cr.height() - sz.height()) / 2, sz.width(), sz.height()); + opt.palette = pal2; + opt.state &= ~QStyle::State_HasFocus; + opt.state &= ~QStyle::State_MouseOver; + if(isEnabled()) + opt.state |= QStyle::State_Enabled; + if (checked) + opt.state |= QStyle::State_On; + else + opt.state |= QStyle::State_Off; + if (isEnabled() && table()->isEnabled()) + opt.state |= QStyle::State_Enabled; + table()->style()->drawPrimitive(QStyle::PE_IndicatorCheckBox, &opt, p, table()); + if (selected) + p->setPen(pal.highlightedText().color()); + else + p->setPen(pal.text().color()); + opt.rect.setRect(0, 0, cr.width(), cr.height()); + QRect textRect = table()->style()->subElementRect(QStyle::SE_CheckBoxContents, &opt, table()); + p->drawText(textRect, wordWrap() ? (alignment() | Qt::WordBreak) : alignment(), text()); +} + +/*! + If \a b is true the checkbox is checked; if \a b is false the + checkbox is unchecked. + + \sa isChecked() +*/ + +void Q3CheckTableItem::setChecked(bool b) +{ + checked = b; + table()->updateCell(row(), col()); + QWidget *w = table()->cellWidget(row(), col()); + QCheckBox *cb = qobject_cast<QCheckBox*>(w); + if (cb) + cb->setChecked(b); +} + +/*! + Returns true if the checkbox table item is checked; otherwise + returns false. + + \sa setChecked() +*/ + +bool Q3CheckTableItem::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()); + QWidget *w = table()->cellWidget(row(), col()); + QCheckBox *cb = qobject_cast<QCheckBox*>(w); + if (cb) + return cb->isChecked(); + return checked; +} + +int Q3CheckTableItem::RTTI = 2; + +/*! + \fn int Q3CheckTableItem::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 Q3TableItem::rtti() +*/ + +int Q3CheckTableItem::rtti() const +{ + return RTTI; +} + +/*! \reimp */ + +QSize Q3CheckTableItem::sizeHint() const +{ + QSize sz = QSize(table()->style()->pixelMetric(QStyle::PM_IndicatorWidth), + table()->style()->pixelMetric(QStyle::PM_IndicatorHeight)); + sz.setWidth(sz.width() + 6); + QSize sh(Q3TableItem::sizeHint()); + return QSize(sh.width() + sz.width(), QMAX(sh.height(), sz.height())). + expandedTo(QApplication::globalStrut()); +} + +/*! + \class Q3Table + \brief The Q3Table class provides a flexible editable table widget. + + \compat + + Q3Table is easy to use, although it does have a large API because + of the comprehensive functionality that it provides. Q3Table + includes functions for manipulating \link #headers + headers\endlink, \link #columnsrows rows and columns\endlink, + \link #cells cells\endlink and \link #selections + selections\endlink. Q3Table also provides in-place editing and + drag and drop, as well as a useful set of + \link #signals signals\endlink. Q3Table efficiently supports very + large tables, for example, tables one million by one million cells + are perfectly possible. Q3Table is economical with memory, using + none for unused cells. + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3table.cpp 3 + + 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. Q3Table cells can be populated with + \l{Q3TableItem}s, \l{Q3ComboTableItem}s or by \l{Q3CheckTableItem}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 Q3Table begin at 0.) + + If you want to use mouse tracking call setMouseTracking(true) on + the \e viewport. + + \img qtableitems.png Table Items + + \target headers + \section1 Headers + + Q3Table 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 Q3Header::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 Q3Header regarding section numbers is overridden + for Q3Table. 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 movable 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 Q3Header + section numbers is overridden by Q3Table. Currently in Q3Table, 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 Q3Header. + The Q3Table Q3Header 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 Q3TableItem. + + The row and column which have the focus are returned by + currentRow() and currentColumn() respectively. + + Although many Q3Table 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 Q3Table'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 Q3TableItems or Q3TableItem + subclasses. The second approach doesn't use Q3TableItems 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 Q3TableItem for the cell if one doesn't already exist, and + displays the text in it. By default the table item's widget will + be a QLineEdit. A pixmap may be put in a cell with setPixmap(), + which also creates a table item if required. A cell may contain \e + both a pixmap and text; the pixmap is displayed to the left of the + text. Another approach is to construct a Q3TableItem or Q3TableItem + subclass, set its properties, then insert it into a cell with + setItem(). + + If you want cells which contain comboboxes use the Q3ComboTableItem + class. Similarly if you require cells containing checkboxes use + the Q3CheckTableItem class. These table items look and behave just + like the combobox or checkbox widgets but consume far less memory. + + Q3Table takes ownership of its Q3TableItems 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 Q3TableItems, and the values in + Q3ComboTableItems and Q3CheckTableItems works automatically. Cells + may be editable or read-only, see Q3TableItem::EditType. If you + want fine control over editing see beginEdit() and endEdit(). + + The contents of a cell can be retrieved as a Q3TableItem using + item(), or as a string with text() or as a pixmap (if there is + one) with pixmap(). A cell's bounding rectangle is given by + cellGeometry(). Use updateCell() to repaint a cell, for example to + clear away a cell's visual representation after it has been + deleted with clearCell(). The table can be forced to scroll to + show a particular cell with ensureCellVisible(). The isSelected() + function indicates if a cell is selected. + + It is possible to use your own widget as a cell's widget using + setCellWidget(), but subclassing Q3TableItem 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 Q3TableItems 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 Q3Table 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 Q3TableItems and + QWidgets, i.e. only store references to cells that are actually + used, many of the functions can be implemented with a single line + of code. + + For more information on cells see the Q3TableItem documenation. + + \target selections + \section1 Selections + + Q3Table'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. + + Q3Table'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 Q3TableSelection objects. + + To easily add a new selection use selectCells(), selectRow() or + selectColumn(). + + Alternatively, use addSelection() to add new selections using + Q3TableSelection objects. The advantage of using Q3TableSelection + objects is that you can call Q3TableSelection::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 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() 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 Q3Table::currentChanged(int row, int col) + + This signal is emitted when the current cell has changed to \a + row, \a col. +*/ + +/*! + \fn void Q3Table::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 Q3Table::currentRow() const + + Returns the current row. + + \sa currentColumn() +*/ + +/*! + \fn int Q3Table::currentColumn() const + + Returns the current column. + + \sa currentRow() +*/ + +/*! + \enum Q3Table::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 Q3Table::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 Q3Table::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 Q3Table::clicked(int row, int col, int button, const QPoint &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 Qt::MouseButton +*/ + +/*! + \fn void Q3Table::doubleClicked(int row, int col, int button, const QPoint &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 Qt::MouseButton +*/ + +/*! + \fn void Q3Table::pressed(int row, int col, int button, const QPoint &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 Qt::MouseButton +*/ + +/*! + \fn void Q3Table::selectionChanged() + + This signal is emitted whenever a selection changes. + + \sa Q3TableSelection +*/ + +/*! + \fn void Q3Table::contextMenuRequested(int row, int col, const QPoint & 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 + parent. + + Call setNumRows() and setNumCols() to set the table size before + populating the table if you're using Q3TableItems. +*/ + +Q3Table::Q3Table(QWidget *parent, const char *name) + : Q3ScrollView(parent, name, WNoAutoErase | 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 parent. + + If you're using \l{Q3TableItem}s to populate the table's cells, you + can create Q3TableItem, Q3ComboTableItem and Q3CheckTableItem items + and insert them into the table using setItem(). (See the notes on + large tables for an alternative to using Q3TableItems.) +*/ + +Q3Table::Q3Table(int numRows, int numCols, QWidget *parent, const char *name) + : Q3ScrollView(parent, name, WNoAutoErase | 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 Q3Table::init(int rows, int cols) +{ +#ifndef QT_NO_DRAGANDDROP + setDragAutoScroll(false); +#endif + d = new Q3TablePrivate; + d->geomTimer = new QTimer(this); + d->lastVisCol = 0; + d->lastVisRow = 0; + connect(d->geomTimer, SIGNAL(timeout()), this, 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); + setFocusPolicy(Qt::WheelFocus); + + viewport()->setBackgroundMode(PaletteBase); + setBackgroundMode(PaletteBackground, PaletteBase); + setResizePolicy(Manual); + selections.setAutoDelete(true); + + // Create headers + leftHeader = new Q3TableHeader(rows, this, this, "left table header"); + leftHeader->setOrientation(Vertical); + leftHeader->setTracking(true); + leftHeader->setMovingEnabled(true); + topHeader = new Q3TableHeader(cols, this, this, "right table header"); + topHeader->setOrientation(Horizontal); + topHeader->setTracking(true); + topHeader->setMovingEnabled(true); + if (QApplication::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, QMAX(100, QApplication::globalStrut().height())); + for (i = 0; i < numRows(); ++i) + leftHeader->resizeSection(i, QMAX(20, QApplication::globalStrut().width())); + topHeader->setUpdatesEnabled(true); + leftHeader->setUpdatesEnabled(true); + + // Prepare for contents + contents.setAutoDelete(false); + + // Connect header, table and scroll bars + connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), + topHeader, SLOT(setOffset(int))); + connect(verticalScrollBar(), SIGNAL(valueChanged(int)), + leftHeader, SLOT(setOffset(int))); + connect(topHeader, SIGNAL(sectionSizeChanged(int)), + this, SLOT(columnWidthChanged(int))); + connect(topHeader, SIGNAL(indexChange(int,int,int)), + this, SLOT(columnIndexChanged(int,int,int))); + connect(topHeader, SIGNAL(sectionClicked(int)), + this, SLOT(columnClicked(int))); + connect(leftHeader, SIGNAL(sectionSizeChanged(int)), + this, SLOT(rowHeightChanged(int))); + connect(leftHeader, SIGNAL(indexChange(int,int,int)), + this, SLOT(rowIndexChanged(int,int,int))); + + // Initialize variables + autoScrollTimer = new QTimer(this); + connect(autoScrollTimer, SIGNAL(timeout()), + this, SLOT(doAutoScroll())); + curRow = curCol = 0; + topHeader->setSectionState(curCol, Q3TableHeader::Bold); + leftHeader->setSectionState(curRow, Q3TableHeader::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 Q3Table object, + including all \l{Q3TableItem}s and their widgets. +*/ + +Q3Table::~Q3Table() +{ + setUpdatesEnabled(false); + contents.setAutoDelete(true); + contents.clear(); + widgets.clear(); + + delete d; +} + +void Q3Table::setReadOnly(bool b) +{ + readOnly = b; + + Q3TableItem *i = item(curRow, curCol); + if (readOnly && isEditing()) { + endEdit(editRow, editCol, true, false); + } else if (!readOnly && i && (i->editType() == Q3TableItem::WhenCurrent + || i->editType() == Q3TableItem::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. + + \sa isRowReadOnly() setColumnReadOnly() setReadOnly() +*/ + +void Q3Table::setRowReadOnly(int row, bool ro) +{ + if (ro) + roRows.replace(row, new int(0)); + else + roRows.remove(row); + + if (curRow == row) { + Q3TableItem *i = item(curRow, curCol); + if (ro && isEditing()) { + endEdit(editRow, editCol, true, false); + } else if (!ro && i && (i->editType() == Q3TableItem::WhenCurrent + || i->editType() == Q3TableItem::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. + + \sa isColumnReadOnly() setRowReadOnly() setReadOnly() + +*/ + +void Q3Table::setColumnReadOnly(int col, bool ro) +{ + if (ro) + roCols.replace(col, new int(0)); + else + roCols.remove(col); + + if (curCol == col) { + Q3TableItem *i = item(curRow, curCol); + if (ro && isEditing()) { + endEdit(editRow, editCol, true, false); + } else if (!ro && i && (i->editType() == Q3TableItem::WhenCurrent + || i->editType() == Q3TableItem::Always)) { + editCell(curRow, curCol); + } + } +} + +/*! + \property Q3Table::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 Q3TableItem::EditType EditType\endlink, and this setting. + + \sa QWidget::enabled setColumnReadOnly() setRowReadOnly() +*/ + +bool Q3Table::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 Q3TableItem::EditType EditType\endlink, and this + setting. + + \sa setRowReadOnly() isColumnReadOnly() +*/ + +bool Q3Table::isRowReadOnly(int row) const +{ + return (roRows.find(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. + + \sa setColumnReadOnly() isRowReadOnly() +*/ + +bool Q3Table::isColumnReadOnly(int col) const +{ + return (roCols.find(col) != 0); +} + +void Q3Table::setSelectionMode(SelectionMode mode) +{ + if (mode == selMode) + return; + selMode = mode; + clearSelection(); + if (isRowSelection(selMode) && numRows() > 0 && numCols() > 0) { + currentSel = new Q3TableSelection(); + selections.append(currentSel); + currentSel->init(curRow, 0); + currentSel->expandTo(curRow, numCols() - 1); + repaintSelections(0, currentSel); + } +} + +/*! + \property Q3Table::selectionMode + \brief the current selection mode + + The default mode is \c Multi which allows the user to select + multiple ranges of cells. +*/ + +Q3Table::SelectionMode Q3Table::selectionMode() const +{ + return selMode; +} + +/*! + \property Q3Table::focusStyle + \brief how the current (focus) cell is drawn + + The default style is \c SpreadSheet. + + \sa Q3Table::FocusStyle +*/ + +void Q3Table::setFocusStyle(FocusStyle fs) +{ + focusStl = fs; + updateCell(curRow, curCol); +} + +Q3Table::FocusStyle Q3Table::focusStyle() const +{ + return focusStl; +} + +/*! + This functions updates all the header states to be in sync with + the current selections. This should be called after + programmatically changing, adding or removing selections, so that + the headers are updated. +*/ + +void Q3Table::updateHeaderStates() +{ + horizontalHeader()->setUpdatesEnabled(false); + verticalHeader()->setUpdatesEnabled(false); + + ((Q3TableHeader*)verticalHeader())->setSectionStateToAll(Q3TableHeader::Normal); + ((Q3TableHeader*)horizontalHeader())->setSectionStateToAll(Q3TableHeader::Normal); + + Q3PtrListIterator<Q3TableSelection> it(selections); + Q3TableSelection *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, Q3TableHeader::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, Q3TableHeader::Selected); + } + } + } + + horizontalHeader()->setUpdatesEnabled(true); + verticalHeader()->setUpdatesEnabled(true); + horizontalHeader()->repaint(false); + verticalHeader()->repaint(false); +} + +/*! + Returns the table's top Q3Header. + + This header contains the column labels. + + To modify a column label use Q3Header::setLabel(). + + \sa verticalHeader() setTopMargin() Q3Header +*/ + +Q3Header *Q3Table::horizontalHeader() const +{ + return (Q3Header*)topHeader; +} + +/*! + Returns the table's vertical Q3Header. + + This header contains the row labels. + + \sa horizontalHeader() setLeftMargin() Q3Header +*/ + +Q3Header *Q3Table::verticalHeader() const +{ + return (Q3Header*)leftHeader; +} + +void Q3Table::setShowGrid(bool b) +{ + if (sGrid == b) + return; + sGrid = b; + updateContents(); +} + +/*! + \property Q3Table::showGrid + \brief whether the table's grid is displayed + + The grid is shown by default. +*/ + +bool Q3Table::showGrid() const +{ + return sGrid; +} + +/*! + \property Q3Table::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. + + \sa rowMovingEnabled +*/ + +void Q3Table::setColumnMovingEnabled(bool b) +{ + mCols = b; +} + +bool Q3Table::columnMovingEnabled() const +{ + return mCols; +} + +/*! + \property Q3Table::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. + + + \sa columnMovingEnabled +*/ + +void Q3Table::setRowMovingEnabled(bool b) +{ + mRows = b; +} + +bool Q3Table::rowMovingEnabled() const +{ + return mRows; +} + +/*! + This is called when Q3Table's internal array needs to be resized to + \a len elements. + + If you don't use Q3TableItems you should reimplement this as an + empty method to avoid wasting memory. See the notes on large + tables for further details. +*/ + +void Q3Table::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{Q3TableItem}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 Q3Table, you will have to do + this manually, e.g. by calling updateContents(). + + \sa swapColumns() swapCells() +*/ + +void Q3Table::swapRows(int row1, int row2, bool swapHeader) +{ + if (swapHeader) + leftHeader->swapSections(row1, row2, false); + + Q3PtrVector<Q3TableItem> tmpContents; + tmpContents.resize(numCols()); + Q3PtrVector<QWidget> tmpWidgets; + tmpWidgets.resize(numCols()); + int i; + + contents.setAutoDelete(false); + widgets.setAutoDelete(false); + for (i = 0; i < numCols(); ++i) { + Q3TableItem *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); + } + + QWidget *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 Q3Table::setLeftMargin(int m) +{ + if (QApplication::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 Q3Table::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{Q3TableItem}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 Q3Table::swapColumns(int col1, int col2, bool swapHeader) +{ + if (swapHeader) + topHeader->swapSections(col1, col2, false); + + Q3PtrVector<Q3TableItem> tmpContents; + tmpContents.resize(numRows()); + Q3PtrVector<QWidget> tmpWidgets; + tmpWidgets.resize(numRows()); + int i; + + contents.setAutoDelete(false); + widgets.setAutoDelete(false); + for (i = 0; i < numRows(); ++i) { + Q3TableItem *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); + } + + QWidget *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{Q3TableItem}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 Q3Table::swapCells(int row1, int col1, int row2, int col2) +{ + contents.setAutoDelete(false); + widgets.setAutoDelete(false); + Q3TableItem *i1, *i2; + i1 = item(row1, col1); + i2 = item(row2, col2); + if (i1 || i2) { + Q3TableItem *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); + } + } + + QWidget *w1, *w2; + w1 = cellWidget(row1, col1); + w2 = cellWidget(row2, col2); + if (w1 || w2) { + QWidget *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(QWidget *child, QWidget *parent) +{ + while (child) { + if (child == parent) + 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 Q3Table::drawContents(QPainter *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(qApp->focusWidget(), viewport()) + || !style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this); + if (rowlast == -1) + rowlast = numRows() - 1; + if (collast == -1) + collast = numCols() - 1; + + bool currentInSelection = false; + + Q3PtrListIterator<Q3TableSelection> it( selections ); + Q3TableSelection *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; + + Q3TableItem *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, QRect(colp, rowp, colw, rowh), selected); + p->translate(-colp, -rowp); + + rowp = oldrp; + rowh = oldrh; + + QWidget *w = cellWidget(r, c); + QRect cg(cellGeometry(r, c)); + if (w && w->geometry() != QRect(contentsToViewport(cg.topLeft()), cg.size() - QSize(1, 1))) { + moveChild(w, colp, rowp); + w->resize(cg.size() - QSize(1, 1)); + } + } + } + d->lastVisCol = collast; + d->lastVisRow = rowlast; + + // draw indication of current cell + QRect 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 Q3Table::drawContents(QPainter *) +{ +} + +/*! + Returns the geometry of cell \a row, \a col in the cell's + coordinate system. This is a convenience function useful in + paintCell(). It is equivalent to QRect(QPoint(0,0), cellGeometry( + row, col).size()); + + \sa cellGeometry() +*/ + +QRect Q3Table::cellRect(int row, int col) const +{ + return QRect(QPoint(0,0), cellGeometry(row, col).size()); +} + +/*! + \overload + + Use the other paintCell() function. This function is only included + for backwards compatibility. +*/ + +void Q3Table::paintCell(QPainter* p, int row, int col, + const QRect &cr, bool selected) +{ + if (cr.width() == 0 || cr.height() == 0) + return; +#if defined(Q_WS_WIN) + const QColorGroup &cg = (!drawActiveSelection && style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus) ? palette().inactive() : colorGroup()); +#else + const QColorGroup &cg = colorGroup(); +#endif + + Q3TableItem *itm = item(row, col); + QColorGroup cg2(cg); + if (itm && !itm->isEnabled()) + cg2 = palette().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 + Q3TableItem and reimplement Q3TableItem::paint() to do the custom + drawing. + + If you're using a Q3TableItem subclass, for example, to store a + data structure, then reimplementing Q3TableItem::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{Q3TableItem}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: + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3table.cpp 4 +*/ + +void Q3Table::paintCell(QPainter *p, int row, int col, + const QRect &cr, bool selected, const QColorGroup &cg) +{ + if (focusStl == SpreadSheet && selected && + row == curRow && + col == curCol && (hasFocus() || viewport()->hasFocus())) + selected = false; + + QPalette pal = cg; + int w = cr.width(); + int h = cr.height(); + int x2 = w - 1; + int y2 = h - 1; + + + Q3TableItem *itm = item(row, col); + if (itm) { + p->save(); + itm->paint(p, pal, cr, selected); + p->restore(); + } else { + p->fillRect(0, 0, w, h, selected ? pal.brush(QPalette::Highlight) : pal.brush(QPalette::Base)); + } + + if (sGrid) { + // Draw our lines + QPen pen(p->pen()); + int gridColor = style()->styleHint(QStyle::SH_Table_GridLineColor, 0, this); + if (gridColor != -1) { + if (palette() != pal) + p->setPen(pal.mid().color()); + else + p->setPen((QRgb)gridColor); + } else { + p->setPen(pal.mid().color()); + } + 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 geometry in content coordinates. +*/ + +void Q3Table::paintFocus(QPainter *p, const QRect &cr) +{ + if (!hasFocus() && !viewport()->hasFocus()) + return; + QRect focusRect(0, 0, cr.width(), cr.height()); + if (focusStyle() == SpreadSheet) { + p->setPen(QPen(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 { + QStyleOptionFocusRect opt; + opt.init(this); + opt.rect = focusRect; + opt.palette = palette(); + opt.state |= QStyle::State_KeyboardFocusChange; + if (isSelected(curRow, curCol, false)) { + opt.state |= QStyle::State_FocusAtBorder; + opt.backgroundColor = palette().highlight().color(); + } else { + opt.state |= QStyle::State_None; + opt.backgroundColor = palette().base().color(); + } + style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p, this); + } +} + +/*! + 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 Q3Table::paintEmptyArea(QPainter *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 + QSize ts(tableSize()); + ts.setWidth(QMIN(ts.width(), visibleWidth())); + ts.setHeight(QMIN(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); + QRegion reg(QRect(cx, cy, cw, ch)); + + // Subtract the table from it + reg = reg.subtracted(QRect(QPoint(0, 0), ts)); + + // And draw the rectangles (transformed inc contents coordinates as needed) + Q3MemArray<QRect> r = reg.rects(); + for (int i = 0; i < (int)r.count(); ++i) + p->fillRect(QRect(viewportToContents2(r[i].topLeft()),r[i].size()), viewport()->backgroundBrush()); +} + +/*! + Returns the Q3TableItem 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{Q3TableItem}s you may need to reimplement this + function: see the notes on large tables. + + \sa setItem() +*/ + +Q3TableItem *Q3Table::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 replaced with \a item. The + table takes ownership of the table item. + + If you don't use \l{Q3TableItem}s you may need to reimplement this + function: see the notes on large tables. + + \sa item() takeItem() +*/ + +void Q3Table::setItem(int row, int col, Q3TableItem *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() == Q3TableItem::WhenCurrent) { + if (beginEdit(row, col, false)) + setEditMode(Editing, row, col); + } +} + +/*! + Removes the Q3TableItem at \a row, \a col. + + If you don't use \l{Q3TableItem}s you may need to reimplement this + function: see the notes on large tables. +*/ + +void Q3Table::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 Q3TableItem is created + with an \link Q3TableItem::EditType EditType\endlink of \c OnTyping, + otherwise the existing table item's text (if any) is replaced with + \a text. + + \sa text() setPixmap() setItem() Q3TableItem::setText() +*/ + +void Q3Table::setText(int row, int col, const QString &text) +{ + Q3TableItem *itm = item(row, col); + if (itm) { + itm->setText(text); + itm->updateEditor(row, col); + updateCell(row, col); + } else { + Q3TableItem *i = new Q3TableItem(this, Q3TableItem::OnTyping, + text, QPixmap()); + 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 Q3TableItem is created + with an \link Q3TableItem::EditType EditType\endlink of \c OnTyping, + otherwise the existing table item's pixmap (if any) is replaced + with \a pix. + + Note that \l{Q3ComboTableItem}s and \l{Q3CheckTableItem}s don't show + pixmaps. + + \sa pixmap() setText() setItem() Q3TableItem::setPixmap() +*/ + +void Q3Table::setPixmap(int row, int col, const QPixmap &pix) +{ + Q3TableItem *itm = item(row, col); + if (itm) { + itm->setPixmap(pix); + updateCell(row, col); + } else { + Q3TableItem *i = new Q3TableItem(this, Q3TableItem::OnTyping, + QString(), pix); + setItem(row, col, i); + } +} + +/*! + Returns the text in the cell at \a row, \a col, or an empty string + if the relevant item does not exist or has no text. + + \sa setText() setPixmap() +*/ + +QString Q3Table::text(int row, int col) const +{ + Q3TableItem *itm = item(row, col); + if (itm) + return itm->text(); + return QString(); +} + +/*! + Returns the pixmap set for the cell at \a row, \a col, or a + null-pixmap if the cell contains no pixmap. + + \sa setPixmap() +*/ + +QPixmap Q3Table::pixmap(int row, int col) const +{ + Q3TableItem *itm = item(row, col); + if (itm) + return itm->pixmap(); + return QPixmap(); +} + +/*! + Moves the focus to the cell at \a row, \a col. + + \sa currentRow() currentColumn() +*/ + +void Q3Table::setCurrentCell(int row, int col) +{ + setCurrentCell(row, col, true, true); +} + +// need to use a define, as leftMargin() is protected +#define VERTICALMARGIN \ +(QApplication::reverseLayout() ? \ + rightMargin() \ + : \ + leftMargin() \ +) + +/*! + \reimp +*/ +QVariant Q3Table::inputMethodQuery(Qt::InputMethodQuery query) const +{ + if (query == Qt::ImMicroFocus) + return QRect(columnPos(curCol) + leftMargin() - contentsX(), rowPos(curRow) + topMargin() - contentsY(), + columnWidth(curCol), rowHeight(curRow)); + return QWidget::inputMethodQuery(query); + +} + +/*! \internal */ + +void Q3Table::setCurrentCell(int row, int col, bool updateSelections, bool ensureVisible) +{ + Q3TableItem *oldItem = item(curRow, curCol); + + if (row > numRows() - 1) + row = numRows() - 1; + if (col > numCols() - 1) + col = numCols() - 1; + + if (curRow == row && curCol == col) + return; + + + Q3TableItem *itm = oldItem; + if (itm && itm->editType() != Q3TableItem::Always && itm->editType() != Q3TableItem::Never) + endEdit(curRow, curCol, 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, Q3TableHeader::Normal); + else if (isRowSelection(selectionMode())) + topHeader->setSectionState(oldCol, Q3TableHeader::Selected); + topHeader->setSectionState(curCol, isColumnSelected(curCol, true) ? + Q3TableHeader::Selected : Q3TableHeader::Bold); + } + + if (oldRow != curRow) { + if (!isRowSelected(oldRow)) + leftHeader->setSectionState(oldRow, Q3TableHeader::Normal); + leftHeader->setSectionState(curRow, isRowSelected(curRow, true) ? + Q3TableHeader::Selected : Q3TableHeader::Bold); + } + + itm = item(curRow, curCol); + + + if (cellWidget(oldRow, oldCol) && + cellWidget(oldRow, oldCol)->hasFocus()) + viewport()->setFocus(); + + if (itm && itm->editType() == Q3TableItem::WhenCurrent) { + if (beginEdit(curRow, curCol, false)) + setEditMode(Editing, row, col); + } else if (itm && itm->editType() == Q3TableItem::Always) { + if (cellWidget(itm->row(), itm->col())) + cellWidget(itm->row(), itm->col())->setFocus(); + } + + if (updateSelections && isRowSelection(selectionMode()) && + !isSelected(curRow, curCol, false)) { + if (selectionMode() == Q3Table::SingleRow) + clearSelection(); + currentSel = new Q3TableSelection(); + 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 Q3Table::ensureCellVisible(int row, int col) +{ + if (!updatesEnabled() || !viewport()->updatesEnabled()) + 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 Q3Table::isSelected(int row, int col) const +{ + return isSelected(row, col, true); +} + +/*! \internal */ + +bool Q3Table::isSelected(int row, int col, bool includeCurrent) const +{ + Q3PtrListIterator<Q3TableSelection> it(selections); + Q3TableSelection *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 Q3Table::isRowSelected(int row, bool full) const +{ + if (!full) { + Q3PtrListIterator<Q3TableSelection> it(selections); + Q3TableSelection *s; + while ((s = it.current()) != 0) { + ++it; + if (s->isActive() && + row >= s->topRow() && + row <= s->bottomRow()) + return true; + if (row == currentRow()) + return true; + } + } else { + Q3PtrListIterator<Q3TableSelection> it(selections); + Q3TableSelection *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 Q3Table::isColumnSelected(int col, bool full) const +{ + if (!full) { + Q3PtrListIterator<Q3TableSelection> it(selections); + Q3TableSelection *s; + while ((s = it.current()) != 0) { + ++it; + if (s->isActive() && + col >= s->leftCol() && + col <= s->rightCol()) + return true; + if (col == currentColumn()) + return true; + } + } else { + Q3PtrListIterator<Q3TableSelection> it(selections); + Q3TableSelection *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 Q3Table::numSelections + \brief The number of selections. + + \sa currentSelection() +*/ + +int Q3Table::numSelections() const +{ + return selections.count(); +} + +/*! + Returns selection number \a num, or an inactive Q3TableSelection if \a + num is out of range (see Q3TableSelection::isActive()). +*/ + +Q3TableSelection Q3Table::selection(int num) const +{ + if (num < 0 || num >= (int)selections.count()) + return Q3TableSelection(); + + Q3TableSelection *s = ((Q3Table*)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 Q3TableSelection::init() and + Q3TableSelection::expandTo() to make the selection valid (see also + Q3TableSelection::isActive(), or use the + Q3TableSelection(int,int,int,int) constructor). + + \sa numSelections() removeSelection() clearSelection() +*/ + +int Q3Table::addSelection(const Q3TableSelection &s) +{ + if (!s.isActive()) + return -1; + + const int maxr = numRows()-1; + const int maxc = numCols()-1; + currentSel = new Q3TableSelection(QMIN(s.anchorRow(), maxr), QMIN(s.anchorCol(), maxc), + QMIN(s.bottomRow(), maxr), QMIN(s.rightCol(), maxc)); + + selections.append(currentSel); + + repaintSelections(0, currentSel, 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 Q3Table::removeSelection(const Q3TableSelection &s) +{ + selections.setAutoDelete(false); + for (Q3TableSelection *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 Q3Table::removeSelection(int num) +{ + if (num < 0 || num >= (int)selections.count()) + return; + + Q3TableSelection *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 Q3Table::currentSelection() const +{ + if (!currentSel) + return -1; + return ((Q3Table*)this)->selections.findRef(currentSel); +} + +/*! Selects the range starting at \a start_row and \a start_col and + ending at \a end_row and \a end_col. + + \sa Q3TableSelection +*/ + +void Q3Table::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 = QMIN(maxr, QMAX(0, start_row)); + start_col = QMIN(maxc, QMAX(0, start_col)); + end_row = QMIN(maxr, end_row); + end_col = QMIN(maxc, end_col); + Q3TableSelection sel(start_row, start_col, end_row, end_col); + addSelection(sel); +} + +/*! Selects the row \a row. + + \sa Q3TableSelection +*/ + +void Q3Table::selectRow(int row) +{ + row = QMIN(numRows()-1, row); + if (row < 0) + return; + if (selectionMode() == SingleRow) { + setCurrentCell(row, currentColumn()); + } else { + Q3TableSelection sel(row, 0, row, numCols() - 1); + addSelection(sel); + } +} + +/*! Selects the column \a col. + + \sa Q3TableSelection +*/ + +void Q3Table::selectColumn(int col) +{ + col = QMIN(numCols()-1, col); + if (col < 0) + return; + Q3TableSelection sel(0, col, numRows() - 1, col); + addSelection(sel); +} + +/*! \reimp +*/ +void Q3Table::contentsMousePressEvent(QMouseEvent* e) +{ + contentsMousePressEventEx(e); +} + +void Q3Table::contentsMousePressEventEx(QMouseEvent* e) +{ + shouldClearSelection = false; + if (isEditing()) { + if (!cellGeometry(editRow, editCol).contains(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(); + } + + Q3TableItem *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 Q3TableSelection(); + selections.append(currentSel); + if (!isRowSelection(selectionMode())) + currentSel->init(oldRow, oldCol); + else + currentSel->init(oldRow, 0); + } + Q3TableSelection 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 Q3TableSelection(); + 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); + Q3TableItem *itm = item(tmpRow, tmpCol); + if (itm && itm->editType() == Q3TableItem::WhenCurrent) { + QWidget *w = cellWidget(tmpRow, tmpCol); + if (qobject_cast<Q3ComboBox*>(w) || qobject_cast<QAbstractButton*>(w)) { + QMouseEvent ev(e->type(), w->mapFromGlobal(e->globalPos()), + e->globalPos(), e->button(), e->state()); + QApplication::sendPostedEvents(w, 0); + QApplication::sendEvent(w, &ev); + d->redirectMouseEvent = true; + } + } + if (isSelected(tmpRow, tmpCol, false)) { + shouldClearSelection = true; + } else { + bool b = signalsBlocked(); + if (selMode != NoSelection) + blockSignals(true); + clearSelection(); + blockSignals(b); + if (selMode != NoSelection) { + currentSel = new Q3TableSelection(); + 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 Q3Table::contentsMouseDoubleClickEvent(QMouseEvent *e) +{ + if (e->button() != LeftButton) + return; + if (!isRowSelection(selectionMode())) + clearSelection(); + int tmpRow = rowAt(e->pos().y()); + int tmpCol = columnAt(e->pos().x()); + Q3TableItem *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 Q3Table::setEditMode(EditMode mode, int row, int col) +{ + edMode = mode; + editRow = row; + editCol = col; +} + + +/*! \reimp +*/ + +void Q3Table::contentsMouseMoveEvent(QMouseEvent *e) +{ + if ((e->state() & MouseButtonMask) == 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 QT_NO_DRAGANDDROP + if (dragEnabled() && startDragRow != -1 && startDragCol != -1) { + if (QPoint(dragStartPos - e->pos()).manhattanLength() > QApplication::startDragDistance()) + startDrag(); + return; + } +#endif + if (selectionMode() == MultiRow && (e->state() & ControlButton) == ControlButton) + shouldClearSelection = false; + + if (shouldClearSelection) { + clearSelection(); + if (selMode != NoSelection) { + currentSel = new Q3TableSelection(); + selections.append(currentSel); + if (!isRowSelection(selectionMode())) + currentSel->init(tmpRow, tmpCol); + else + currentSel->init(tmpRow, 0); + emit selectionChanged(); + } + shouldClearSelection = false; + } + + QPoint pos = mapFromGlobal(e->globalPos()); + pos -= QPoint(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 Q3Table::doValueChanged() +{ + emit valueChanged(editRow, editCol); +} + +/*! \internal +*/ + +void Q3Table::doAutoScroll() +{ + QPoint pos = QCursor::pos(); + pos = mapFromGlobal(pos); + pos -= QPoint(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 += QPoint(contentsX(), contentsY()); + if (tmpRow == curRow) + tmpRow = rowAt(pos.y()); + if (tmpCol == curCol) + tmpCol = columnAt(pos.x()); + pos -= QPoint(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) { + Q3TableSelection 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 Q3TableSelection(); + 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 Q3Table::contentsMouseReleaseEvent(QMouseEvent *e) +{ + if (pressedRow == curRow && pressedCol == curCol) + emit clicked(curRow, curCol, e->button(), e->pos()); + + if (e->button() != 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 Q3TableSelection(); + 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() == + Q3TableItem::WhenCurrent) { + QWidget *w = cellWidget(pressedRow, pressedCol); + if (w) { + QMouseEvent ev(e->type(), w->mapFromGlobal(e->globalPos()), + e->globalPos(), e->button(), e->state()); + QApplication::sendPostedEvents(w, 0); + bool old = w->testAttribute(Qt::WA_NoMousePropagation); + w->setAttribute(Qt::WA_NoMousePropagation, true); + QApplication::sendEvent(w, &ev); + w->setAttribute(Qt::WA_NoMousePropagation, old); + } + } +} + +/*! + \reimp +*/ + +void Q3Table::contentsContextMenuEvent(QContextMenuEvent *e) +{ + if (!receivers(SIGNAL(contextMenuRequested(int,int,QPoint)))) { + e->ignore(); + return; + } + if (e->reason() == QContextMenuEvent::Keyboard) { + QRect 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 Q3Table::eventFilter(QObject *o, QEvent *e) +{ + switch (e->type()) { + case QEvent::KeyPress: { + Q3TableItem *itm = item(curRow, curCol); + QWidget *editorWidget = cellWidget(editRow, editCol); + + if (isEditing() && editorWidget && o == editorWidget) { + itm = item(editRow, editCol); + QKeyEvent *ke = (QKeyEvent*)e; + if (ke->key() == Key_Escape) { + if (!itm || itm->editType() == Q3TableItem::OnTyping) + endEdit(editRow, editCol, false, edMode != Editing); + return true; + } + + if ((ke->state() == NoButton || ke->state() == Keypad) + && (ke->key() == Key_Return || ke->key() == Key_Enter)) { + if (!itm || itm->editType() == Q3TableItem::OnTyping) + endEdit(editRow, editCol, true, edMode != Editing); + activateNextCell(); + return true; + } + + if (ke->key() == Key_Tab || ke->key() == Key_BackTab) { + if (ke->state() & Qt::ControlButton) + return false; + if (!itm || itm->editType() == Q3TableItem::OnTyping) + endEdit(editRow, editCol, true, edMode != Editing); + if ((ke->key() == Key_Tab) && !(ke->state() & ShiftButton)) { + if (currentColumn() >= numCols() - 1) + return true; + int cc = QMIN(numCols() - 1, currentColumn() + 1); + while (cc < numCols()) { + Q3TableItem *i = item(currentRow(), cc); + if (!d->hiddenCols.find(cc) && !isColumnReadOnly(cc) && (!i || i->isEnabled())) + break; + ++cc; + } + setCurrentCell(currentRow(), cc); + } else { // Key_BackTab + if (currentColumn() == 0) + return true; + int cc = QMAX(0, currentColumn() - 1); + while (cc >= 0) { + Q3TableItem *i = item(currentRow(), cc); + if (!d->hiddenCols.find(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() == Q3TableItem::WhenCurrent)) && + (ke->key() == Key_Up || ke->key() == Key_Prior || + ke->key() == Key_Home || ke->key() == Key_Down || + ke->key() == Key_Next || ke->key() == Key_End || + ke->key() == Key_Left || ke->key() == Key_Right)) { + if (!itm || itm->editType() == Q3TableItem::OnTyping) { + endEdit(editRow, editCol, true, edMode != Editing); + } + keyPressEvent(ke); + return true; + } + } else { + QObjectList l = viewport()->queryList("QWidget"); + if (l.contains(o)) { + QKeyEvent *ke = (QKeyEvent*)e; + if ((ke->state() & ControlButton) == ControlButton || + (ke->key() != Key_Left && ke->key() != Key_Right && + ke->key() != Key_Up && ke->key() != Key_Down && + ke->key() != Key_Prior && ke->key() != Key_Next && + ke->key() != Key_Home && ke->key() != Key_End)) + return false; + keyPressEvent((QKeyEvent*)e); + return true; + } + } + + } break; + case QEvent::FocusOut: { + QWidget *editorWidget = cellWidget(editRow, editCol); + if (isEditing() && editorWidget && o == editorWidget && ((QFocusEvent*)e)->reason() != Qt::PopupFocusReason) { + // if the editor is the parent of the new focus widget, do nothing + QWidget *w = QApplication::focusWidget(); + while (w) { + w = w->parentWidget(); + if (w == editorWidget) + break; + } + if (w) + break; + // otherwise, end editing + Q3TableItem *itm = item(editRow, editCol); + if (!itm || itm->editType() == Q3TableItem::OnTyping) { + endEdit(editRow, editCol, true, edMode != Editing); + return true; + } + } + break; + } +#ifndef QT_NO_WHEELEVENT + case QEvent::Wheel: + if (o == this || o == viewport()) { + QWheelEvent* we = (QWheelEvent*)e; + scrollBy(0, -we->delta()); + we->accept(); + return true; + } +#endif + default: + break; + } + + return Q3ScrollView::eventFilter(o, e); +} + +void Q3Table::fixCell(int &row, int &col, int key) +{ + if (rowHeight(row) > 0 && columnWidth(col) > 0) + return; + if (rowHeight(row) <= 0) { + if (key == Key_Down || + key == Key_Next || + key == Key_End) { + while (row < numRows() && rowHeight(row) <= 0) + row++; + if (rowHeight(row) <= 0) + row = curRow; + } else if (key == Key_Up || + key == Key_Prior || + key == Key_Home) + while (row >= 0 && rowHeight(row) <= 0) + row--; + if (rowHeight(row) <= 0) + row = curRow; + } else if (columnWidth(col) <= 0) { + if (key == Key_Left) { + while (col >= 0 && columnWidth(col) <= 0) + col--; + if (columnWidth(col) <= 0) + col = curCol; + } else if (key == Key_Right) { + while (col < numCols() && columnWidth(col) <= 0) + col++; + if (columnWidth(col) <= 0) + col = curCol; + } + } +} + +/*! \reimp +*/ + +void Q3Table::keyPressEvent(QKeyEvent* e) +{ + if (isEditing() && item(editRow, editCol) && + item(editRow, editCol)->editType() == Q3TableItem::OnTyping) + return; + + int tmpRow = curRow; + int tmpCol = curCol; + int oldRow = tmpRow; + int oldCol = tmpCol; + + bool navigationKey = false; + int r; + switch (e->key()) { + case Key_Left: + tmpCol = QMAX(0, tmpCol - 1); + navigationKey = true; + break; + case Key_Right: + tmpCol = QMIN(numCols() - 1, tmpCol + 1); + navigationKey = true; + break; + case Key_Up: + tmpRow = QMAX(0, tmpRow - 1); + navigationKey = true; + break; + case Key_Down: + tmpRow = QMIN(numRows() - 1, tmpRow + 1); + navigationKey = true; + break; + case Key_Prior: + r = QMAX(0, rowAt(rowPos(tmpRow) - visibleHeight())); + if (r < tmpRow || tmpRow < 0) + tmpRow = r; + navigationKey = true; + break; + case Key_Next: + r = QMIN(numRows() - 1, rowAt(rowPos(tmpRow) + visibleHeight())); + if (r > tmpRow) + tmpRow = r; + else + tmpRow = numRows() - 1; + navigationKey = true; + break; + case Key_Home: + tmpRow = 0; + navigationKey = true; + break; + case Key_End: + tmpRow = numRows() - 1; + navigationKey = true; + break; + case Key_F2: + if (beginEdit(tmpRow, tmpCol, false)) + setEditMode(Editing, tmpRow, tmpCol); + break; + case Key_Enter: case Key_Return: + activateNextCell(); + return; + case Key_Tab: case Key_BackTab: + if ((e->key() == Key_Tab) && !(e->state() & ShiftButton)) { + if (currentColumn() >= numCols() - 1) + return; + int cc = QMIN(numCols() - 1, currentColumn() + 1); + while (cc < numCols()) { + Q3TableItem *i = item(currentRow(), cc); + if (!d->hiddenCols.find(cc) && !isColumnReadOnly(cc) && (!i || i->isEnabled())) + break; + ++cc; + } + setCurrentCell(currentRow(), cc); + } else { // Key_BackTab + if (currentColumn() == 0) + return; + int cc = QMAX(0, currentColumn() - 1); + while (cc >= 0) { + Q3TableItem *i = item(currentRow(), cc); + if (!d->hiddenCols.find(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()) { + Q3TableItem *itm = item(tmpRow, tmpCol); + if (!itm || itm->editType() == Q3TableItem::OnTyping) { + QWidget *w = beginEdit(tmpRow, tmpCol, + itm ? itm->isReplaceable() : true); + if (w) { + setEditMode((!itm || (itm && itm->isReplaceable()) + ? Replacing : Editing), tmpRow, tmpCol); + QApplication::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 Q3TableSelection(); + selections.append(currentSel); + if (!isRowSelection(selectionMode())) + currentSel->init(oldRow, oldCol); + else + currentSel->init(oldRow < 0 ? 0 : oldRow, 0); + } + Q3TableSelection 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; + Q3TableSelection oldSelection; + if (selectionMode() == MultiRow) { + bool b = signalsBlocked(); + blockSignals(true); + clearSelection(); + blockSignals(b); + } else { + if (currentSel) { + oldSelection = *currentSel; + hasOldSel = true; + selections.removeRef(currentSel); + leftHeader->setSectionState(oldSelection.topRow(), Q3TableHeader::Normal); + } + } + currentSel = new Q3TableSelection(); + 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 Q3Table::focusInEvent(QFocusEvent*) +{ + d->inMenuMode = false; + QWidget *editorWidget = cellWidget(editRow, editCol); + updateCell(curRow, curCol); + if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) + repaintSelections(); + if (isEditing() && editorWidget) + editorWidget->setFocus(); + +} + + +/*! \reimp +*/ + +void Q3Table::focusOutEvent(QFocusEvent *e) +{ + updateCell(curRow, curCol); + if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) { + d->inMenuMode = + e->reason() == Qt::PopupFocusReason || + (qApp->focusWidget() && qApp->focusWidget()->inherits("QMenuBar")); + if (!d->inMenuMode) + repaintSelections(); + } +} + +/*! \reimp +*/ + +QSize Q3Table::sizeHint() const +{ + if (cachedSizeHint().isValid()) + return cachedSizeHint(); + + constPolish(); + + QSize s = tableSize(); + QSize sh; + if (s.width() < 500 && s.height() < 500) { + sh = QSize(tableSize().width() + VERTICALMARGIN + 5, + tableSize().height() + topMargin() + 5); + } else { + sh = Q3ScrollView::sizeHint(); + if (!topHeader->isHidden()) + sh.setHeight(sh.height() + topHeader->height()); + if (!leftHeader->isHidden()) + sh.setWidth(sh.width() + leftHeader->width()); + } + setCachedSizeHint(sh); + return sh; +} + +/*! \reimp +*/ + +void Q3Table::viewportResizeEvent(QResizeEvent *e) +{ + Q3ScrollView::viewportResizeEvent(e); + updateGeometries(); +} + +/*! \reimp +*/ + +void Q3Table::showEvent(QShowEvent *e) +{ + Q3ScrollView::showEvent(e); + QRect r(cellGeometry(numRows() - 1, numCols() - 1)); + resizeContents(r.right() + 1, r.bottom() + 1); + updateGeometries(); +} + +/*! \reimp +*/ + +void Q3Table::paintEvent(QPaintEvent *e) +{ + QRect topLeftCorner = QStyle::visualRect(layoutDirection(), rect(), QRect(frameWidth(), frameWidth(), VERTICALMARGIN, topMargin())); + erase(topLeftCorner); // erase instead of widget on top + Q3ScrollView::paintEvent(e); + +#ifdef Q_OS_WINCE + QPainter 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 Q3Table::updateCell(int row, int col) +{ + if (inUpdateCell || row < 0 || col < 0) + return; + inUpdateCell = true; + QRect cg = cellGeometry(row, col); + QRect r(contentsToViewport(QPoint(cg.x() - 2, cg.y() - 2)), + QSize(cg.width() + 4, cg.height() + 4)); + viewport()->update(r); + inUpdateCell = false; +} + +void Q3Table::repaintCell(int row, int col) +{ + if (row == -1 || col == -1) + return; + QRect cg = cellGeometry(row, col); + QRect r(QPoint(cg.x() - 2, cg.y() - 2), + QSize(cg.width() + 4, cg.height() + 4)); + repaintContents(r, false); +} + +void Q3Table::contentsToViewport2(int x, int y, int& vx, int& vy) +{ + const QPoint v = contentsToViewport2(QPoint(x, y)); + vx = v.x(); + vy = v.y(); +} + +QPoint Q3Table::contentsToViewport2(const QPoint &p) +{ + return QPoint(p.x() - contentsX(), + p.y() - contentsY()); +} + +QPoint Q3Table::viewportToContents2(const QPoint& vp) +{ + return QPoint(vp.x() + contentsX(), + vp.y() + contentsY()); +} + +void Q3Table::viewportToContents2(int vx, int vy, int& x, int& y) +{ + const QPoint c = viewportToContents2(QPoint(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 geometry of any affected columns + and repaints the table to reflect the changes it has made. +*/ + +void Q3Table::columnWidthChanged(int col) +{ + int p = columnPos(col); + if (d->hasColSpan) + p = contentsX(); + updateContents(p, contentsY(), contentsWidth(), visibleHeight()); + QSize 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 geometry of any affected rows and + repaints the table to reflect the changes it has made. +*/ + +void Q3Table::rowHeightChanged(int row) +{ + int p = rowPos(row); + if (d->hasRowSpan) + p = contentsY(); + updateContents(contentsX(), p, visibleWidth(), contentsHeight()); + QSize 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 Q3Table::updateRowWidgets(int row) +{ + for (int i = 0; i < numCols(); ++i) { + QWidget *w = cellWidget(row, i); + if (!w) + continue; + moveChild(w, columnPos(i), rowPos(row)); + w->resize(columnWidth(i) - 1, rowHeight(row) - 1); + } +} + +/*! \internal */ + +void Q3Table::updateColWidgets(int col) +{ + for (int i = 0; i < numRows(); ++i) { + QWidget *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 Q3Header::indexChange() rowIndexChanged() +*/ + +void Q3Table::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 Q3Header::indexChange() columnIndexChanged() +*/ + +void Q3Table::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 Q3Table::columnClicked(int col) +{ + if (!sorting()) + return; + + if (col == lastSortCol) { + asc = !asc; + } else { + lastSortCol = col; + asc = true; + } + sortColumn(lastSortCol, asc); +} + +/*! + \property Q3Table::sorting + \brief whether a click on the header of a column sorts that column + + \sa sortColumn() +*/ + +void Q3Table::setSorting(bool b) +{ + doSort = b; + if (topHeader) + topHeader->setSortIndicator(b ? lastSortCol : -1); +} + +bool Q3Table::sorting() const +{ + return doSort; +} + +static bool inUpdateGeometries = false; + +void Q3Table::delayedUpdateGeometries() +{ + d->geomTimer->start(0, true); +} + +void Q3Table::updateGeometriesSlot() +{ + updateGeometries(); +} + +/*! + This function updates the geometries of the left and top header. + You do not normally need to call this function. +*/ + +void Q3Table::updateGeometries() +{ + if (inUpdateGeometries) + return; + inUpdateGeometries = true; + QSize 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(QStyle::visualRect(layoutDirection(), rect(), QRect(frameWidth(), topMargin() + frameWidth(), + VERTICALMARGIN, visibleHeight()))); + topHeader->setGeometry(QStyle::visualRect(layoutDirection(), rect(), QRect(VERTICALMARGIN + frameWidth(), frameWidth(), + visibleWidth(), topMargin()))); + horizontalScrollBar()->raise(); + verticalScrollBar()->raise(); + topHeader->updateStretches(); + leftHeader->updateStretches(); + inUpdateGeometries = false; +} + +/*! + Returns the width of column \a col. + + \sa setColumnWidth() rowHeight() +*/ + +int Q3Table::columnWidth(int col) const +{ + return topHeader->sectionSize(col); +} + +/*! + Returns the height of row \a row. + + \sa setRowHeight() columnWidth() +*/ + +int Q3Table::rowHeight(int row) const +{ + return leftHeader->sectionSize(row); +} + +/*! + Returns the x-coordinate of the column \a col in content + coordinates. + + \sa columnAt() rowPos() +*/ + +int Q3Table::columnPos(int col) const +{ + return topHeader->sectionPos(col); +} + +/*! + Returns the y-coordinate of the row \a row in content coordinates. + + \sa rowAt() columnPos() +*/ + +int Q3Table::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 Q3Table::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 Q3Table::rowAt(int y) const +{ + return leftHeader->sectionAt(y); +} + +/*! + Returns the bounding rectangle of the cell at \a row, \a col in + content coordinates. +*/ + +QRect Q3Table::cellGeometry(int row, int col) const +{ + Q3TableItem *itm = item(row, col); + + if (!itm || (itm->rowSpan() == 1 && itm->colSpan() == 1)) + return QRect(columnPos(col), rowPos(row), + columnWidth(col), rowHeight(row)); + + while (row != itm->row()) + row--; + while (col != itm->col()) + col--; + + QRect 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. +*/ + +QSize Q3Table::tableSize() const +{ + return QSize(columnPos(numCols() - 1) + columnWidth(numCols() - 1), + rowPos(numRows() - 1) + rowHeight(numRows() - 1)); +} + +/*! + \property Q3Table::numRows + \brief The number of rows in the table + + \sa numCols +*/ + +int Q3Table::numRows() const +{ + return leftHeader->count(); +} + +/*! + \property Q3Table::numCols + \brief The number of columns in the table + + \sa numRows +*/ + +int Q3Table::numCols() const +{ + return topHeader->count(); +} + +void Q3Table::saveContents(Q3PtrVector<Q3TableItem> &tmp, + Q3PtrVector<Q3Table::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) { + Q3TableItem *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) { + QWidget *w = widgets[ i ]; + if (w) + tmp2.insert(i, new TableWidget(w, i / nCols, i % nCols)); + else + tmp2.insert(i, 0); + } +} + +void Q3Table::updateHeaderAndResizeContents(Q3TableHeader *header, + int num, int rowCol, + int width, bool &updateBefore) +{ + updateBefore = rowCol < num; + if (rowCol > num) { + header->Q3Header::resizeArrays(rowCol); + header->Q3TableHeader::resizeArrays(rowCol); + int old = num; + clearSelection(false); + int i = 0; + for (i = old; i < rowCol; ++i) + header->addLabel(QString(), 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 Q3Table::restoreContents(Q3PtrVector<Q3TableItem> &tmp, + Q3PtrVector<Q3Table::TableWidget> &tmp2) +{ + int i; + int nCols = numCols(); + for (i = 0; i < (int)tmp.size(); ++i) { + Q3TableItem *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 Q3Table::finishContentsResze(bool updateBefore) +{ + QRect 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 Q3Table::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.find(rr)) + d->hiddenRows.remove(rr); + } + } + + fontChange(font()); // invalidate the sizeHintCache + + Q3PtrVector<Q3TableItem> tmp; + Q3PtrVector<TableWidget> tmp2; + saveContents(tmp, tmp2); + + bool updatesEnabled = leftHeader->updatesEnabled(); + if (updatesEnabled) + leftHeader->setUpdatesEnabled(false); + + bool updateBefore; + updateHeaderAndResizeContents(leftHeader, numRows(), r, 20, updateBefore); + + int w = fontMetrics().width(QString::number(r) + QLatin1Char('W')); + if (VERTICALMARGIN > 0 && w > VERTICALMARGIN) + setLeftMargin(w); + + restoreContents(tmp, tmp2); + + leftHeader->calculatePositions(); + finishContentsResze(updateBefore); + if (updatesEnabled) { + leftHeader->setUpdatesEnabled(true); + 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 Q3Table::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.find(cc)) + d->hiddenCols.remove(cc); + } + } + + fontChange(font()); // invalidate the sizeHintCache + + Q3PtrVector<Q3TableItem> tmp; + Q3PtrVector<TableWidget> tmp2; + saveContents(tmp, tmp2); + + bool updatesEnabled = topHeader->updatesEnabled(); + if (updatesEnabled) + topHeader->setUpdatesEnabled(false); + + bool updateBefore; + updateHeaderAndResizeContents(topHeader, numCols(), c, 100, updateBefore); + + restoreContents(tmp, tmp2); + + topHeader->calculatePositions(); + finishContentsResze(updateBefore); + if (updatesEnabled) { + topHeader->setUpdatesEnabled(true); + 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 Q3Table::setRowLabels(const QStringList &labels) +{ + leftHeader->setLabels(labels); +} + +/*! Sets the section labels of the horizontalHeader() to \a labels */ + +void Q3Table::setColumnLabels(const QStringList &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 replaced 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 Q3TableItem and the table item's + Q3TableItem::isReplaceable() is false then the cell is asked to + create an appropriate editor (using Q3TableItem::createEditor()). + Otherwise a QLineEdit is used as the editor. + + If you want to create your own editor for certain cells, implement + a custom Q3TableItem subclass and reimplement + Q3TableItem::createEditor(). + + If you are not using \l{Q3TableItem}s and you don't want to use a + QLineEdit as the default editor, subclass Q3Table and reimplement + this function with code like this: + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3table.cpp 5 + 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 Q3TableItem::createEditor() +*/ + +QWidget *Q3Table::createEditor(int row, int col, bool initFromCell) const +{ + if (isReadOnly() || isRowReadOnly(row) || isColumnReadOnly(col)) + return 0; + + QWidget *e = 0; + + // the current item in the cell should be edited if possible + Q3TableItem *i = item(row, col); + if (initFromCell || (i && !i->isReplaceable())) { + if (i) { + if (i->editType() == Q3TableItem::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 QLineEdit(viewport(), "qt_lineeditor"); + ((QLineEdit*)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 replace the cell's content + with the editor's content.) If \a replace is true the editor will + start empty; otherwise it will be initialized with the cell's + content (if any), i.e. the user will be modifying the original + cell content. + + \sa endEdit() +*/ + +QWidget *Q3Table::beginEdit(int row, int col, bool replace) +{ + if (isReadOnly() || isRowReadOnly(row) || isColumnReadOnly(col)) + return 0; + if ( row < 0 || row >= numRows() || col < 0 || col >= numCols() ) + return 0; + Q3TableItem *itm = item(row, col); + if (itm && !itm->isEnabled()) + return 0; + if (cellWidget(row, col)) + return 0; + ensureCellVisible(row, col); + QWidget *e = createEditor(row, col, !replace); + 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 replace is true the current content of + this cell should be replaced by the content of the editor (this + means removing the current Q3TableItem 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 Q3TableItem of this cell. + + setCellContentFromEditor() is called to replace the contents of + the cell with the contents of the cell's editor. + + Finally clearCellWidget() is called to remove the editor widget. + + \sa setCellContentFromEditor(), beginEdit() +*/ + +void Q3Table::endEdit(int row, int col, bool accept, bool replace) +{ + QWidget *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; + } + + Q3TableItem *i = item(row, col); + QString oldContent; + if (i) + oldContent = i->text(); + + if (!i || replace) { + 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 replace the contents of the cell at \a + row, \a col with the contents of the cell's editor. + + If there already exists a Q3TableItem for the cell, + it calls Q3TableItem::setContentFromEditor() on this Q3TableItem. + + If, for example, you want to create different \l{Q3TableItem}s + depending on the contents of the editor, you might reimplement + this function. + + If you want to work without \l{Q3TableItem}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 Q3TableItem::setContentFromEditor() createEditor() +*/ + +void Q3Table::setCellContentFromEditor(int row, int col) +{ + QWidget *editor = cellWidget(row, col); + if (!editor) + return; + + Q3TableItem *i = item(row, col); + if (i) { + i->setContentFromEditor(editor); + } else { + QLineEdit *le = qobject_cast<QLineEdit*>(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 Q3Table::EditMode +*/ + +bool Q3Table::isEditing() const +{ + return edMode != NotEditing; +} + +/*! + Returns the current edit mode + + \sa Q3Table::EditMode +*/ + +Q3Table::EditMode Q3Table::editMode() const +{ + return edMode; +} + +/*! + Returns the current edited row +*/ + +int Q3Table::currEditRow() const +{ + return editRow; +} + +/*! + Returns the current edited column +*/ + +int Q3Table::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 Q3IntDict to map integers to the cells that are used. +*/ + +int Q3Table::indexOf(int row, int col) const +{ + return (row * numCols()) + col; +} + +/*! \internal +*/ + +void Q3Table::repaintSelections(Q3TableSelection *oldSelection, + Q3TableSelection *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; + + QRect old; + if (oldSelection) + old = rangeGeometry(oldSelection->topRow(), + oldSelection->leftCol(), + oldSelection->bottomRow(), + oldSelection->rightCol(), + optimizeOld); + else + old = QRect(0, 0, 0, 0); + + QRect cur; + if (newSelection) + cur = rangeGeometry(newSelection->topRow(), + newSelection->leftCol(), + newSelection->bottomRow(), + newSelection->rightCol(), + optimizeNew); + else + cur = QRect(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) { + QRect rr = cur.united(old); + repaintContents(rr, false); + } else { + old = QRect(contentsToViewport2(old.topLeft()), old.size()); + cur = QRect(contentsToViewport2(cur.topLeft()), cur.size()); + QRegion r1(old); + QRegion r2(cur); + QRegion r3 = r1.subtracted(r2); + QRegion r4 = r2.subtracted(r1); + + for (i = 0; i < (int)r3.rects().count(); ++i) { + QRect r(r3.rects()[ i ]); + r = QRect(viewportToContents2(r.topLeft()), r.size()); + repaintContents(r, false); + } + for (i = 0; i < (int)r4.rects().count(); ++i) { + QRect r(r4.rects()[ i ]); + r = QRect(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 = QMIN(oldTopRow, newTopRow); + } + + { + int oldLeftCol = oldSelection ? oldSelection->leftCol() : numCols() - 1; + int newLeftCol = newSelection ? newSelection->leftCol() : numCols() - 1; + left = QMIN(oldLeftCol, newLeftCol); + } + + { + int oldBottomRow = oldSelection ? oldSelection->bottomRow() : 0; + int newBottomRow = newSelection ? newSelection->bottomRow() : 0; + bottom = QMAX(oldBottomRow, newBottomRow); + } + + { + int oldRightCol = oldSelection ? oldSelection->rightCol() : 0; + int newRightCol = newSelection ? newSelection->rightCol() : 0; + right = QMAX(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 = Q3TableHeader::Normal; + else if (isColumnSelected(i, true)) + *s = Q3TableHeader::Selected; + else + *s = Q3TableHeader::Bold; + ++s; + } + topHeader->repaint(false); + } + + if (updateVertical && numRows() > 0 && top >= 0) { + register int *s = &leftHeader->states.data()[top]; + for (i = top; i <= bottom; ++i) { + if (!isRowSelected(i)) + *s = Q3TableHeader::Normal; + else if (isRowSelected(i, true)) + *s = Q3TableHeader::Selected; + else + *s = Q3TableHeader::Bold; + ++s; + } + leftHeader->repaint(false); + } +} + +/*! + Repaints all selections +*/ + +void Q3Table::repaintSelections() +{ + if (selections.isEmpty()) + return; + + QRect r; + for (Q3TableSelection *s = selections.first(); s; s = selections.next()) { + bool b; + r = r.united(rangeGeometry(s->topRow(), + s->leftCol(), + s->bottomRow(), + s->rightCol(), b)); + } + + repaintContents(r, false); +} + +/*! + Clears all selections and repaints the appropriate regions if \a + repaint is true. + + \sa removeSelection() +*/ + +void Q3Table::clearSelection(bool repaint) +{ + if (selections.isEmpty()) + return; + bool needRepaint = !selections.isEmpty(); + + QRect r; + for (Q3TableSelection *s = selections.first(); s; s = selections.next()) { + bool b; + r = r.united(rangeGeometry(s->topRow(), + s->leftCol(), + s->bottomRow(), + s->rightCol(), b)); + } + + currentSel = 0; + selections.clear(); + + if (needRepaint && repaint) + repaintContents(r, false); + + leftHeader->setSectionStateToAll(Q3TableHeader::Normal); + leftHeader->repaint(false); + if (!isRowSelection(selectionMode())) { + topHeader->setSectionStateToAll(Q3TableHeader::Normal); + topHeader->repaint(false); + } + topHeader->setSectionState(curCol, Q3TableHeader::Bold); + leftHeader->setSectionState(curRow, Q3TableHeader::Bold); + emit selectionChanged(); +} + +/*! \internal +*/ + +QRect Q3Table::rangeGeometry(int topRow, int leftCol, + int bottomRow, int rightCol, bool &optimize) +{ + topRow = QMAX(topRow, rowAt(contentsY())); + leftCol = QMAX(leftCol, columnAt(contentsX())); + int ra = rowAt(contentsY() + visibleHeight()); + if (ra != -1) + bottomRow = QMIN(bottomRow, ra); + int ca = columnAt(contentsX() + visibleWidth()); + if (ca != -1) + rightCol = QMIN(rightCol, ca); + optimize = true; + QRect rect; + for (int r = topRow; r <= bottomRow; ++r) { + for (int c = leftCol; c <= rightCol; ++c) { + rect = rect.united(cellGeometry(r, c)); + Q3TableItem *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 Q3Table::activateNextCell() +{ + int firstRow = 0; + while (d->hiddenRows.find(firstRow)) + firstRow++; + int firstCol = 0; + while (d->hiddenCols.find(firstCol)) + firstCol++; + int nextRow = curRow; + int nextCol = curCol; + while (d->hiddenRows.find(++nextRow)) {} + if (nextRow >= numRows()) { + nextRow = firstRow; + while (d->hiddenCols.find(++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 Q3Table::fixRow(int &row, int y) +{ + if (row == -1) { + if (y < 0) + row = 0; + else + row = numRows() - 1; + } +} + +/*! \internal +*/ + +void Q3Table::fixCol(int &col, int x) +{ + if (col == -1) { + if (x < 0) + col = 0; + else + col = numCols() - 1; + } +} + +struct SortableTableItem +{ + Q3TableItem *item; +}; + +#if defined(Q_C_CALLBACKS) +extern "C" { +#endif + +#ifdef Q_OS_WINCE +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(Q_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 Q3TableItems you will need to + reimplement swapRows() and swapCells(). (See the notes on large + tables.) + + \sa swapRows() +*/ + +void Q3Table::sortColumn(int col, bool ascending, bool wholeRows) +{ + int filledRows = 0, i; + for (i = 0; i < numRows(); ++i) { + Q3TableItem *itm = item(i, col); + if (itm) + filledRows++; + } + + if (!filledRows) + return; + + SortableTableItem *items = new SortableTableItem[ filledRows ]; + int j = 0; + for (i = 0; i < numRows(); ++i) { + Q3TableItem *itm = item(i, col); + if (!itm) + continue; + items[ j++ ].item = itm; + } + + qsort(items, filledRows, sizeof(SortableTableItem), cmpTableItems); + + bool updatesWereEnabled = updatesEnabled(); + if (updatesWereEnabled) + 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); + } + } + } + if (updatesWereEnabled) + setUpdatesEnabled(true); + if (topHeader) + topHeader->setSortIndicator(col, ascending ? Qt::Ascending : Qt::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 Q3Table::hideRow(int row) +{ + if (d->hiddenRows.find(row)) + return; + d->hiddenRows.replace(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 ? Key_Up : Key_Down); + fixCell(r, c, k); + if (numRows() > 0) + setCurrentCell(r, c); + } +} + +/*! + Hides column \a col. + + \sa showColumn() hideRow() +*/ + +void Q3Table::hideColumn(int col) +{ + if (!numCols() || d->hiddenCols.find(col)) + return; + d->hiddenCols.replace(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 ? Key_Left : Key_Right); + fixCell(r, c, k); + if (numCols() > 0) + setCurrentCell(r, c); + } +} + +/*! + Shows row \a row. + + \sa hideRow() showColumn() +*/ + +void Q3Table::showRow(int row) +{ + int *h = d->hiddenRows.find(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 Q3Table::showColumn(int col) +{ + int *w = d->hiddenCols.find(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 Q3Table::isRowHidden(int row) const +{ + return d->hiddenRows.find(row); +} + +/*! + Returns true if column \a col is hidden; otherwise returns + false. + + \sa hideColumn(), isRowHidden() +*/ +bool Q3Table::isColumnHidden(int col) const +{ + return d->hiddenCols.find(col); +} + +/*! + Resizes column \a col to be \a w pixels wide. + + \sa columnWidth() setRowHeight() +*/ + +void Q3Table::setColumnWidth(int col, int w) +{ + int *ow = d->hiddenCols.find(col); + if (ow) { + d->hiddenCols.replace(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 Q3Table::setRowHeight(int row, int h) +{ + int *oh = d->hiddenRows.find(row); + if (oh) { + d->hiddenRows.replace(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 contains. + + \sa adjustRow() +*/ + +void Q3Table::adjustColumn(int col) +{ + int w; + if ( currentColumn() == col ) { + QFont f = font(); + f.setBold(true); + w = topHeader->sectionSizeHint( col, QFontMetrics(f) ).width(); + } else { + w = topHeader->sectionSizeHint( col, fontMetrics() ).width(); + } + if (topHeader->iconSet(col)) + w += topHeader->iconSet(col)->pixmap().width(); + w = QMAX(w, 20); + for (int i = 0; i < numRows(); ++i) { + Q3TableItem *itm = item(i, col); + if (!itm) { + QWidget *widget = cellWidget(i, col); + if (widget) + w = QMAX(w, widget->sizeHint().width()); + } else { + if (itm->colSpan() > 1) + w = QMAX(w, itm->sizeHint().width() / itm->colSpan()); + else + w = QMAX(w, itm->sizeHint().width()); + } + } + w = QMAX(w, QApplication::globalStrut().width()); + setColumnWidth(col, w); +} + +/*! + Resizes row \a row so that the row height is tall enough to + display the tallest item the row contains. + + \sa adjustColumn() +*/ + +void Q3Table::adjustRow(int row) +{ + int h = 20; + h = QMAX(h, leftHeader->sectionSizeHint(row, leftHeader->fontMetrics()).height()); + if (leftHeader->iconSet(row)) + h = QMAX(h, leftHeader->iconSet(row)->pixmap().height()); + for (int i = 0; i < numCols(); ++i) { + Q3TableItem *itm = item(row, i); + if (!itm) { + QWidget *widget = cellWidget(row, i); + if (widget) + h = QMAX(h, widget->sizeHint().height()); + } else { + if (itm->rowSpan() > 1) + h = QMAX(h, itm->sizeHint().height() / itm->rowSpan()); + else + h = QMAX(h, itm->sizeHint().height()); + } + } + h = QMAX(h, QApplication::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 Q3Table::setColumnStretchable(int col, bool stretch) +{ + topHeader->setSectionStretchable(col, stretch); + + if (stretch && d->hiddenCols.find(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 Q3Table::setRowStretchable(int row, bool stretch) +{ + leftHeader->setSectionStretchable(row, stretch); + + if (stretch && d->hiddenRows.find(row)) + leftHeader->numStretches--; +} + +/*! + Returns true if column \a col is stretchable; otherwise returns + false. + + \sa setColumnStretchable() isRowStretchable() +*/ + +bool Q3Table::isColumnStretchable(int col) const +{ + return topHeader->isSectionStretchable(col); +} + +/*! + Returns true if row \a row is stretchable; otherwise returns + false. + + \sa setRowStretchable() isColumnStretchable() +*/ + +bool Q3Table::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 Q3Table::takeItem(Q3TableItem *i) +{ + if (!i) + return; + if (i->row() != -1 && i->col() != -1) { + QRect 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 geometry changes. + + By default widgets are inserted into a vector with numRows() * + numCols() elements. In very large tables you will probably want to + store the widgets in a data structure that consumes less memory (see + the notes on large tables). To support the use of your own data + structure this function calls insertWidget() to add the widget to + the internal data structure. To use your own data structure + reimplement insertWidget(), cellWidget() and clearCellWidget(). + + Cell widgets are created dynamically with the \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 Q3Table::setCellWidget(int row, int col, QWidget *e) +{ + if (!e || row >= numRows() || col >= numCols()) + return; + + QWidget *w = cellWidget(row, col); + if (w && row == editRow && col == editCol) + endEdit(editRow, editCol, false, edMode != Editing); + + e->installEventFilter(this); + clearCellWidget(row, col); + if (e->parent() != viewport()) + e->reparent(viewport(), QPoint(0,0)); + Q3TableItem *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); + QRect 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{Q3TableItem}s you may need to reimplement this + function: see the notes on large tables. +*/ + +void Q3Table::insertWidget(int row, int col, QWidget *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{Q3TableItem}s you may need to reimplement this + function: see the notes on large tables. + + \sa clearCellWidget() setCellWidget() +*/ + +QWidget *Q3Table::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()) + ((Q3Table*)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{Q3TableItem}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 QObject::deleteLater() + is called on the widget to avoid problems with timing issues. + + \sa cellWidget() setCellWidget() +*/ + +void Q3Table::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()); + + QWidget *w = cellWidget(row, col); + if (w) { + w->removeEventFilter(this); + w->hide(); + w->deleteLater(); + } + widgets.setAutoDelete(false); + widgets.remove(indexOf(row, col)); + widgets.setAutoDelete(true); +} + +/*! + \fn void Q3Table::dropped (QDropEvent * e) + + This signal is emitted when a drop event occurred on the table. + + \a e contains 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 Q3Table::setDragEnabled(bool b) +{ + dEnabled = b; +} + +/*! + If this function returns true, the table supports dragging. + + \sa setDragEnabled() +*/ + +bool Q3Table::dragEnabled() const +{ + return dEnabled; +} + +/*! + Inserts \a count empty rows at row \a row. Also clears the selection(s). + + \sa insertColumns() removeRow() +*/ + +void Q3Table::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 updatesWereEnabled = updatesEnabled(); + if (updatesWereEnabled) + setUpdatesEnabled(false); + bool leftHeaderUpdatesEnabled = leftHeader->updatesEnabled(); + if (leftHeaderUpdatesEnabled) + leftHeader->setUpdatesEnabled(false); + int oldLeftMargin = leftMargin(); + + setNumRows(numRows() + count); + + for (int i = numRows() - count - 1; i > row; --i) + leftHeader->swapSections(i, i + count); + + if (leftHeaderUpdatesEnabled) + leftHeader->setUpdatesEnabled(leftHeaderUpdatesEnabled); + + if (updatesWereEnabled) + setUpdatesEnabled(true); + + int cr = QMAX(0, currentRow()); + int cc = QMAX(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 repaint + QRect rect(0, y, leftHeader->width(), contentsHeight()); + leftHeader->update(rect); + } + + if (updatesWereEnabled) { + 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 Q3Table::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 updatesWereEnabled = updatesEnabled(); + if (updatesWereEnabled) + setUpdatesEnabled(false); + bool topHeaderUpdatesEnabled = topHeader->updatesEnabled(); + if (topHeaderUpdatesEnabled) + topHeader->setUpdatesEnabled(false); + int oldTopMargin = topMargin(); + + setNumCols(numCols() + count); + + for (int i = numCols() - count - 1; i > col; --i) + topHeader->swapSections(i, i + count); + + if (topHeaderUpdatesEnabled) + topHeader->setUpdatesEnabled(true); + if (updatesWereEnabled) + setUpdatesEnabled(true); + + int cr = QMAX(0, currentRow()); + int cc = QMAX(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 repaint + QRect rect(x, 0, contentsWidth(), topHeader->height()); + topHeader->update(rect); + } + + if (updatesWereEnabled) { + 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 Q3Table::removeRow(int row) +{ + if (row < 0 || row >= numRows()) + return; + if (row < numRows() - 1) { + if (d->hiddenRows.find(row)) + d->hiddenRows.remove(row); + + for (int i = row; i < numRows() - 1; ++i) + ((Q3TableHeader*)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 Q3Table::removeRows(const Q3MemArray<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++) { + ((Q3TableHeader*)verticalHeader())->swapSections(j, j + i + 1); + } + } + + for (int j = rows[i] - i; j < numRows() - (int)rows.size(); j++) + ((Q3TableHeader*)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 Q3Table::removeColumn(int col) +{ + if (col < 0 || col >= numCols()) + return; + if (col < numCols() - 1) { + if (d->hiddenCols.find(col)) + d->hiddenCols.remove(col); + + for (int i = col; i < numCols() - 1; ++i) + ((Q3TableHeader*)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 Q3Table::removeColumns(const Q3MemArray<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++) { + ((Q3TableHeader*)horizontalHeader())->swapSections(j, j + i + 1); + } + } + + for (int j = cols[i] - i; j < numCols() - (int)cols.size(); j++) + ((Q3TableHeader*)horizontalHeader())->swapSections(j, j + cols.count()); + + setNumCols(numCols() - cols.count()); +} + +/*! + Starts editing the cell at \a row, \a col. + + If \a replace is true the content of this cell will be replaced by + the content of the editor when editing is finished, i.e. the user + will be entering new data; otherwise the current content of the + cell (if any) will be modified in the editor. + + \sa beginEdit() +*/ + +void Q3Table::editCell(int row, int col, bool replace) +{ + if (row < 0 || col < 0 || row > numRows() - 1 || col > numCols() - 1) + return; + + if (beginEdit(row, col, replace)) { + edMode = Editing; + editRow = row; + editCol = col; + } +} + +#ifndef QT_NO_DRAGANDDROP + +/*! + This event handler is called whenever a Q3Table object receives a + \l QDragEnterEvent \a e, i.e. when the user pressed the mouse + button to drag something. + + The focus is moved to the cell where the QDragEnterEvent occurred. +*/ + +void Q3Table::contentsDragEnterEvent(QDragEnterEvent *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 (e->source() != (QObject*)cellWidget(currentRow(), currentColumn())) + setCurrentCell(tmpRow, tmpCol, false, true); + e->accept(); +} + +/*! + This event handler is called whenever a Q3Table object receives a + \l QDragMoveEvent \a e, i.e. when the user actually drags the + mouse. + + The focus is moved to the cell where the QDragMoveEvent occurred. +*/ + +void Q3Table::contentsDragMoveEvent(QDragMoveEvent *e) +{ + int tmpRow = rowAt(e->pos().y()); + int tmpCol = columnAt(e->pos().x()); + fixRow(tmpRow, e->pos().y()); + fixCol(tmpCol, e->pos().x()); + if (e->source() != (QObject*)cellWidget(currentRow(), currentColumn())) + setCurrentCell(tmpRow, tmpCol, false, true); + e->accept(); +} + +/*! + This event handler is called when a drag activity leaves \e this + Q3Table object with event \a e. +*/ + +void Q3Table::contentsDragLeaveEvent(QDragLeaveEvent *) +{ + setCurrentCell(oldCurrentRow, oldCurrentCol, false, true); +} + +/*! + This event handler is called when the user ends a drag and drop by + dropping something onto \e this Q3Table and thus triggers the drop + event, \a e. +*/ + +void Q3Table::contentsDropEvent(QDropEvent *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 Q3DragObject depending on the selected items. + + \sa dropped() +*/ + +Q3DragObject *Q3Table::dragObject() +{ + return 0; +} + +/*! + Starts a drag. + + Usually you don't need to call or reimplement this function yourself. + + \sa dragObject() +*/ + +void Q3Table::startDrag() +{ + if (startDragRow == -1 || startDragCol == -1) + return; + + startDragRow = startDragCol = -1; + + Q3DragObject *drag = dragObject(); + if (!drag) + return; + + drag->drag(); +} + +#endif + +/*! \internal */ +void Q3Table::windowActivationChange(bool oldActive) +{ + if (oldActive && autoScrollTimer) + autoScrollTimer->stop(); + + if (!isVisible()) + return; + + if (palette().active() != palette().inactive()) + updateContents(); +} + +/*! + \internal +*/ +void Q3Table::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); + } + Q3ScrollView::setEnabled(b); +} + + +/* + \class Q3TableHeader + \brief The Q3TableHeader class allows for creation and manipulation + of table headers. + + \compat + + Q3Table uses this subclass of Q3Header for its headers. Q3Table has a + horizontalHeader() for displaying column labels, and a + verticalHeader() for displaying row labels. + +*/ + +/* + \enum Q3TableHeader::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 parent and attached to table \a t. +*/ + +Q3TableHeader::Q3TableHeader(int i, Q3Table *t, + QWidget *parent, const char *name) + : Q3Header(i, parent, 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 QTimer(this); + connect(autoScrollTimer, SIGNAL(timeout()), + this, SLOT(doAutoScroll())); +#ifndef NO_LINE_WIDGET + line1 = new QWidget(table->viewport(), "qt_line1"); + line1->hide(); + line1->setBackgroundMode(PaletteText); + table->addChild(line1); + line2 = new QWidget(table->viewport(), "qt_line2"); + line2->hide(); + line2->setBackgroundMode(PaletteText); + table->addChild(line2); +#else + d = new Q3TableHeaderPrivate; + d->oldLinePos = -1; //outside, in contents coords +#endif + connect(this, SIGNAL(sizeChange(int,int,int)), + this, SLOT(sectionWidthChanged(int,int,int))); + connect(this, SIGNAL(indexChange(int,int,int)), + this, SLOT(indexChanged(int,int,int))); + + stretchTimer = new QTimer(this); + widgetStretchTimer = new QTimer(this); + connect(stretchTimer, SIGNAL(timeout()), + this, SLOT(updateStretches())); + connect(widgetStretchTimer, SIGNAL(timeout()), + this, 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 Q3TableHeader::addLabel(const QString &s , int size) +{ + Q3Header::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 Q3TableHeader::removeLabel(int section) +{ + Q3Header::removeLabel(section); + if (section == (int)states.size() - 1) { + states.resize(states.size() - 1); + stretchable.resize(stretchable.size() - 1); + } +} + +void Q3TableHeader::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 Q3TableHeader::setLabel(int section, const QString & s, int size) +{ + Q3Header::setLabel(section, s, size); + sectionLabelChanged(section); +} + +void Q3TableHeader::setLabel(int section, const QIconSet & iconset, + const QString & s, int size) +{ + Q3Header::setLabel(section, iconset, s, size); + sectionLabelChanged(section); +} + +/*! + Sets the SectionState of section \a s to \a astate. + + \sa sectionState() +*/ + +void Q3TableHeader::setSectionState(int s, SectionState astate) +{ + if (s < 0 || s >= (int)states.count()) + return; + if (states.data()[ s ] == astate) + return; + if (isRowSelection(table->selectionMode()) && orientation() == Horizontal) + return; + + states.data()[ s ] = astate; + if (updatesEnabled()) { + if (orientation() == Horizontal) + repaint(sectionPos(s) - offset(), 0, sectionSize(s), height(), false); + else + repaint(0, sectionPos(s) - offset(), width(), sectionSize(s), false); + } +} + +void Q3TableHeader::setSectionStateToAll(SectionState state) +{ + if (isRowSelection(table->selectionMode()) && orientation() == 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() +*/ + +Q3TableHeader::SectionState Q3TableHeader::sectionState(int s) const +{ + return (s < 0 || s >= (int)states.count() ? Normal : (Q3TableHeader::SectionState)states[s]); +} + +/*! \reimp +*/ + +void Q3TableHeader::paintEvent(QPaintEvent *e) +{ + QPainter p(this); + p.setPen(colorGroup().buttonText()); + int pos = orientation() == Horizontal + ? e->rect().left() + : e->rect().top(); + int id = mapToIndex(sectionAt(pos + offset())); + if (id < 0) { + if (pos > 0) + return; + else + id = 0; + } + + QRegion reg = e->region(); + for (int i = id; i < count(); i++) { + QRect r = sRect(i); + reg -= r; + p.save(); + if (!(orientation() == Horizontal && isRowSelection(table->selectionMode())) && + (sectionState(i) == Bold || sectionState(i) == Selected)) { + QFont f(font()); + f.setBold(true); + p.setFont(f); + } + paintSection(&p, i, r); + p.restore(); + if ((orientation() == Horizontal && r. right() >= e->rect().right()) + || (orientation() == Vertical && r. bottom() >= e->rect().bottom())) + return; + } + p.end(); + 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 Q3TableHeader::paintSection(QPainter *p, int index, const QRect& fr) +{ + int section = mapToSection(index); + if (section < 0 || cellSize(section) <= 0) + return; + + if (sectionState(index) != Selected || + (orientation() == Horizontal && isRowSelection(table->selectionMode()))) { + Q3Header::paintSection(p, index, fr); + } else { + QStyleOptionHeader opt; + opt.palette = palette(); + opt.rect = fr; + opt.state = QStyle::State_Off | (orient == Qt::Horizontal ? QStyle::State_Horizontal + : QStyle::State_None); + if (isEnabled()) + opt.state |= QStyle::State_Enabled; + if (isClickEnabled()) { + if (sectionState(index) == Selected) { + opt.state |= QStyle::State_Sunken; + if (!mousePressed) + opt.state |= QStyle::State_On; + } + } + if (!(opt.state & QStyle::State_Sunken)) + opt.state |= QStyle::State_Raised; + style()->drawControl(QStyle::CE_HeaderSection, &opt, p, this); + paintSectionLabel(p, index, fr); + } +} + +static int real_pos(const QPoint &p, Qt::Orientation o) +{ + if (o == Qt::Horizontal) + return p.x(); + return p.y(); +} + +/*! \reimp +*/ + +void Q3TableHeader::mousePressEvent(QMouseEvent *e) +{ + if (e->button() != LeftButton) + return; + Q3Header::mousePressEvent(e); + mousePressed = true; + pressPos = real_pos(e->pos(), orientation()); + if (!table->currentSel || (e->state() & ShiftButton) != ShiftButton) + startPos = -1; + setCaching(true); + resizedSection = -1; +#ifdef QT_NO_CURSOR + isResizing = false; +#else + isResizing = cursor().shape() != ArrowCursor; + if (!isResizing && sectionAt(pressPos) != -1) + doSelection(e); +#endif +} + +/*! \reimp +*/ + +void Q3TableHeader::mouseMoveEvent(QMouseEvent *e) +{ + if ((e->state() & MouseButtonMask) != LeftButton // Using LeftButton simulates old behavior. +#ifndef QT_NO_CURSOR + || cursor().shape() != ArrowCursor +#endif + || ((e->state() & ControlButton) == ControlButton && + (orientation() == Horizontal + ? table->columnMovingEnabled() : table->rowMovingEnabled()))) { + Q3Header::mouseMoveEvent(e); + return; + } + + if (!doSelection(e)) + Q3Header::mouseMoveEvent(e); +} + +bool Q3TableHeader::doSelection(QMouseEvent *e) +{ + int p = real_pos(e->pos(), orientation()) + offset(); + + if (isRowSelection(table->selectionMode())) { + if (orientation() == Horizontal) + return true; + if (table->selectionMode() == Q3Table::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() == Q3Table::Single + || table->selectionMode() == Q3Table::SingleRow) { + startPos = p; + bool b = table->signalsBlocked(); + table->blockSignals(true); + table->clearSelection(); + table->blockSignals(b); + } + saveStates(); + + if (table->selectionMode() != Q3Table::NoSelection) { + startPos = p; + Q3TableSelection *oldSelection = table->currentSel; + + if (orientation() == Vertical) { + if (!table->isRowSelected(secAt, true)) { + table->currentSel = new Q3TableSelection(); + 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 == Horizontal + if (!table->isColumnSelected(secAt, true)) { + table->currentSel = new Q3TableSelection(); + 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() == Horizontal && table->isColumnSelected(secAt)) + || (orientation() == Vertical && table->isRowSelected(secAt))) { + setSectionState(secAt, Selected); + } + + table->repaintSelections(oldSelection, table->currentSel, + orientation() == Horizontal, + orientation() == Vertical); + if (sectionAt(p) != -1) + endPos = p; + + return true; + } + } + + if (sectionAt(p) != -1) + endPos = p; + if (startPos != -1) { + updateSelections(); + p -= offset(); + if (orientation() == Horizontal && (p < 0 || p > width())) { + doAutoScroll(); + autoScrollTimer->start(100, true); + } else if (orientation() == Vertical && (p < 0 || p > height())) { + doAutoScroll(); + autoScrollTimer->start(100, true); + } + return true; + } + return table->selectionMode() == Q3Table::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 Q3TableHeader::sectionLabelChanged(int section) +{ + emit sectionSizeChanged(section); + + // this does not really belong here + if (orientation() == Horizontal) { + int h = sizeHint().height(); + if (h != height() && mayOverwriteMargin(table->topMargin(), h)) + table->setTopMargin(h); + } else { + int w = sizeHint().width(); + if (w != width() && mayOverwriteMargin((QApplication::reverseLayout() ? table->rightMargin() : table->leftMargin()), w)) + table->setLeftMargin(w); + } +} + +/*! \reimp */ +void Q3TableHeader::mouseReleaseEvent(QMouseEvent *e) +{ + if (e->button() != LeftButton) + return; + autoScrollTimer->stop(); + mousePressed = false; + setCaching(false); + Q3Header::mouseReleaseEvent(e); +#ifndef NO_LINE_WIDGET + line1->hide(); + line2->hide(); +#else + if (d->oldLinePos >= 0) + if (orientation() == 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 + QRect selectedRects; + for (int i = 0; i < count(); i++) { + if(sectionState(i) == Selected) + selectedRects |= sRect(i); + } + if(!selectedRects.isNull()) + repaint(selectedRects); +} + +/*! \reimp +*/ + +void Q3TableHeader::mouseDoubleClickEvent(QMouseEvent *e) +{ + if (e->button() != 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() == 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 Q3TableHeader::resizeEvent(QResizeEvent *e) +{ + stretchTimer->stop(); + widgetStretchTimer->stop(); + Q3Header::resizeEvent(e); + if (numStretches == 0) + return; + stretchTimer->start(0, true); +} + +void Q3TableHeader::updateStretches() +{ + if (numStretches == 0) + return; + + int dim = orientation() == 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 = signalsBlocked(); + 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, QMAX(20, pd)); + } + blockSignals(block); + table->repaintContents(false); + widgetStretchTimer->start(100, true); +} + +void Q3TableHeader::updateWidgetStretches() +{ + QSize s = table->tableSize(); + table->resizeContents(s.width(), s.height()); + for (int i = 0; i < table->numCols(); ++i) + table->updateColWidgets(i); +} + +void Q3TableHeader::updateSelections() +{ + if (table->selectionMode() == Q3Table::NoSelection || + (isRowSelection(table->selectionMode()) && orientation() != Vertical )) + return; + int a = sectionAt(startPos); + int b = sectionAt(endPos); + int start = QMIN(a, b); + int end = QMAX(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; + } + repaint(false); + + if (table->currentSel) { + Q3TableSelection oldSelection = *table->currentSel; + if (orientation() == Vertical) + table->currentSel->expandTo(b, table->horizontalHeader()->count() - 1); + else + table->currentSel->expandTo(table->verticalHeader()->count() - 1, b); + table->repaintSelections(&oldSelection, table->currentSel, + orientation() == Horizontal, + orientation() == Vertical); + } + emit table->selectionChanged(); +} + +void Q3TableHeader::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 Q3TableHeader::doAutoScroll() +{ + QPoint pos = mapFromGlobal(QCursor::pos()); + int p = real_pos(pos, orientation()) + offset(); + if (sectionAt(p) != -1) + endPos = p; + if (orientation() == Horizontal) + table->ensureVisible(endPos, table->contentsY()); + else + table->ensureVisible(table->contentsX(), endPos); + updateSelections(); + autoScrollTimer->start(100, true); +} + +void Q3TableHeader::sectionWidthChanged(int col, int, int) +{ + resizedSection = col; + if (orientation() == Horizontal) { +#ifndef NO_LINE_WIDGET + table->moveChild(line1, Q3Header::sectionPos(col) - 1, + table->contentsY()); + line1->resize(1, table->visibleHeight()); + line1->show(); + line1->raise(); + table->moveChild(line2, + Q3Header::sectionPos(col) + Q3Header::sectionSize(col) - 1, + table->contentsY()); + line2->resize(1, table->visibleHeight()); + line2->show(); + line2->raise(); +#else + QPainter p(table->viewport()); + int lx = Q3Header::sectionPos(col) + Q3Header::sectionSize(col) - 1; + int ly = table->contentsY(); + + if (lx != d->oldLinePos) { + QPoint pt = table->contentsToViewport(QPoint(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(), + Q3Header::sectionPos(col) - 1); + line1->resize(table->visibleWidth(), 1); + line1->show(); + line1->raise(); + table->moveChild(line2, table->contentsX(), + Q3Header::sectionPos(col) + Q3Header::sectionSize(col) - 1); + line2->resize(table->visibleWidth(), 1); + line2->show(); + line2->raise(); + +#else + QPainter p(table->viewport()); + int lx = table->contentsX(); + int ly = Q3Header::sectionPos(col) + Q3Header::sectionSize(col) - 1; + + if (ly != d->oldLinePos) { + QPoint pt = table->contentsToViewport(QPoint(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 Q3TableHeader::sectionSize(int section) const +{ + if (count() <= 0 || section < 0 || section >= count()) + return -1; + if (caching && section < (int)sectionSizes.count()) + return sectionSizes[ section ]; + return Q3Header::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 Q3TableHeader::sectionPos(int section) const +{ + if (count() <= 0 || section < 0 || section >= count()) + return -1; + if (caching && section < (int)sectionPoses.count()) + return sectionPoses[ section ]; + return Q3Header::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 Q3TableHeader::sectionAt(int pos) const +{ + if (!caching || sectionSizes.count() <= 0 || sectionPoses.count() <= 0) + return Q3Header::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 Q3TableHeader::updateCache() +{ + sectionPoses.resize(count()); + sectionSizes.resize(count()); + if (!caching) + return; + for (int i = 0; i < count(); ++i) { + sectionSizes[ i ] = Q3Header::sectionSize(i); + sectionPoses[ i ] = Q3Header::sectionPos(i); + } +} + +void Q3TableHeader::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 ] = Q3Header::sectionSize(i); + sectionPoses[ i ] = Q3Header::sectionPos(i); + } + } +} + +/*! + If \a b is true, section \a s is stretchable; otherwise the + section is not stretchable. + + \sa isSectionStretchable() +*/ + +void Q3TableHeader::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 Q3TableHeader::isSectionStretchable(int s) const +{ + return stretchable[ s ]; +} + +void Q3TableHeader::swapSections(int oldIdx, int newIdx, bool swapTable) +{ + extern bool qt_qheader_label_return_null_strings; // qheader.cpp + qt_qheader_label_return_null_strings = true; + + QIconSet oldIconSet, newIconSet; + if (iconSet(oldIdx)) + oldIconSet = *iconSet(oldIdx); + if (iconSet(newIdx)) + newIconSet = *iconSet(newIdx); + QString oldLabel = label(oldIdx); + QString newLabel = label(newIdx); + bool sectionsHasContent = !(oldIconSet.isNull() && newIconSet.isNull() + && oldLabel.isNull() && newLabel.isNull()); + if (sectionsHasContent) { + Q3HeaderData *data = static_cast<Q3Header*>(this)->d; + bool oldNullLabel = qt_get_null_label_bit(data, oldIdx); + bool newNullLabel = qt_get_null_label_bit(data, newIdx); + setLabel(oldIdx, newIconSet, newLabel); + setLabel(newIdx, oldIconSet, oldLabel); + qt_set_null_label_bit(data, oldIdx, newNullLabel); + qt_set_null_label_bit(data, newIdx, oldNullLabel); + } + + 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() == Horizontal) + table->swapColumns(oldIdx, newIdx); + else + table->swapRows(oldIdx, newIdx); +} + +void Q3TableHeader::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 Q3TableHeader::setLabels(const QStringList & labels) +{ + int i = 0; + const int c = QMIN(count(), (int)labels.count()); + bool updates = updatesEnabled(); + if (updates) + setUpdatesEnabled(false); + for (QStringList::ConstIterator it = labels.begin(); i < c; ++i, ++it) { + if (i == c - 1) { + if (updates) + setUpdatesEnabled(true); + setLabel(i, *it); + } else { + Q3Header::setLabel(i, *it); + emit sectionSizeChanged(i); + } + } +} + +QT_END_NAMESPACE + +#include "q3table.moc" |