diff options
Diffstat (limited to 'src/qt3support/itemviews')
| -rw-r--r-- | src/qt3support/itemviews/itemviews.pri | 11 | ||||
| -rw-r--r-- | src/qt3support/itemviews/q3iconview.cpp | 6203 | ||||
| -rw-r--r-- | src/qt3support/itemviews/q3iconview.h | 519 | ||||
| -rw-r--r-- | src/qt3support/itemviews/q3listbox.cpp | 4687 | ||||
| -rw-r--r-- | src/qt3support/itemviews/q3listbox.h | 429 | ||||
| -rw-r--r-- | src/qt3support/itemviews/q3listview.cpp | 7949 | ||||
| -rw-r--r-- | src/qt3support/itemviews/q3listview.h | 609 | ||||
| -rw-r--r-- | src/qt3support/itemviews/q3table.cpp | 7333 | ||||
| -rw-r--r-- | src/qt3support/itemviews/q3table.h | 548 |
9 files changed, 28288 insertions, 0 deletions
diff --git a/src/qt3support/itemviews/itemviews.pri b/src/qt3support/itemviews/itemviews.pri new file mode 100644 index 0000000..cfc8c2d --- /dev/null +++ b/src/qt3support/itemviews/itemviews.pri @@ -0,0 +1,11 @@ +# Qt compat module, old itemviews + +HEADERS += itemviews/q3iconview.h \ + itemviews/q3listbox.h \ + itemviews/q3listview.h \ + itemviews/q3table.h + +SOURCES += itemviews/q3iconview.cpp \ + itemviews/q3listbox.cpp \ + itemviews/q3listview.cpp \ + itemviews/q3table.cpp diff --git a/src/qt3support/itemviews/q3iconview.cpp b/src/qt3support/itemviews/q3iconview.cpp new file mode 100644 index 0000000..d1a9c1e --- /dev/null +++ b/src/qt3support/itemviews/q3iconview.cpp @@ -0,0 +1,6203 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@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 "q3iconview.h" + +#ifndef QT_NO_ICONVIEW + +#include "private/q3richtext_p.h" +#include "q3textedit.h" +#include "qapplication.h" +#include "qbitmap.h" +#include "qbrush.h" +#include "q3cleanuphandler.h" +#include "qcursor.h" +#include "qevent.h" +#include "qfontmetrics.h" +#include "qhash.h" +#include "qimage.h" +#include "qmime.h" +#include "qpainter.h" +#include "qpalette.h" +#include "qpen.h" +#include "qpixmapcache.h" +#include "qstringlist.h" +#include "qstyle.h" +#include "qstyleoption.h" +#include "qtimer.h" +#include "qtooltip.h" +#include "q3strlist.h" + +#include <limits.h> +#include <stdlib.h> + +QT_BEGIN_NAMESPACE + +#define RECT_EXTENSION 300 + +static const char * const unknown_xpm[] = { + "32 32 11 1", + "c c #ffffff", + "g c #c0c0c0", + "a c #c0ffc0", + "h c #a0a0a4", + "d c #585858", + "f c #303030", + "i c #400000", + "b c #00c000", + "e c #000000", + "# c #000000", + ". c None", + "...###..........................", + "...#aa##........................", + ".###baaa##......................", + ".#cde#baaa##....................", + ".#cccdeebaaa##..##f.............", + ".#cccccdeebaaa##aaa##...........", + ".#cccccccdeebaaaaaaaa##.........", + ".#cccccccccdeebaaaaaaa#.........", + ".#cccccgcgghhebbbbaaaaa#........", + ".#ccccccgcgggdebbbbbbaa#........", + ".#cccgcgcgcgghdeebiebbba#.......", + ".#ccccgcggggggghdeddeeba#.......", + ".#cgcgcgcggggggggghghdebb#......", + ".#ccgcggggggggghghghghd#b#......", + ".#cgcgcggggggggghghghhd#b#......", + ".#gcggggggggghghghhhhhd#b#......", + ".#cgcggggggggghghghhhhd#b#......", + ".#ggggggggghghghhhhhhhdib#......", + ".#gggggggggghghghhhhhhd#b#......", + ".#hhggggghghghhhhhhhhhd#b#......", + ".#ddhhgggghghghhhhhhhhd#b#......", + "..##ddhhghghhhhhhhhhhhdeb#......", + "....##ddhhhghhhhhhhhhhd#b#......", + "......##ddhhhhhhhhhhhhd#b#......", + "........##ddhhhhhhhhhhd#b#......", + "..........##ddhhhhhhhhd#b#......", + "............##ddhhhhhhd#b###....", + "..............##ddhhhhd#b#####..", + "................##ddhhd#b######.", + "..................##dddeb#####..", + "....................##d#b###....", + "......................####......"}; + +static QPixmap *unknown_icon = 0; +static QPixmap *qiv_buffer_pixmap = 0; +#if !defined(Q_WS_X11) +static QPixmap *qiv_selection = 0; +#endif +static bool optimize_layout = false; + +static Q3CleanupHandler<QPixmap> qiv_cleanup_pixmap; + + +static QPixmap *get_qiv_buffer_pixmap(const QSize &s) +{ + if (!qiv_buffer_pixmap) { + qiv_buffer_pixmap = new QPixmap(s); + qiv_cleanup_pixmap.add(&qiv_buffer_pixmap); + return qiv_buffer_pixmap; + } + + qiv_buffer_pixmap->resize(s); + return qiv_buffer_pixmap; +} + +#ifndef QT_NO_DRAGANDDROP + +class Q_COMPAT_EXPORT Q3IconDragData +{ +public: + Q3IconDragData(); + Q3IconDragData(const QRect &ir, const QRect &tr); + + QRect pixmapRect() const; + QRect textRect() const; + + void setPixmapRect(const QRect &r); + void setTextRect(const QRect &r); + + QRect iconRect_, textRect_; + QString key_; + + bool operator==(const Q3IconDragData &i) const; +}; + +class Q_COMPAT_EXPORT Q3IconDragDataItem +{ +public: + Q3IconDragDataItem() {} + Q3IconDragDataItem(const Q3IconDragItem &i1, const Q3IconDragData &i2) : data(i1), item(i2) {} + Q3IconDragItem data; + Q3IconDragData item; + bool operator== (const Q3IconDragDataItem&) const; +}; + +class Q3IconDragPrivate +{ +public: + QLinkedList<Q3IconDragDataItem> items; + static bool decode(QMimeSource* e, QLinkedList<Q3IconDragDataItem> &lst); +}; + +#endif + +class Q3IconViewPrivate +{ +public: + Q3IconViewItem *firstItem, *lastItem; + uint count; + Q3IconView::SelectionMode selectionMode; + Q3IconViewItem *currentItem, *tmpCurrentItem, *highlightedItem, + *startDragItem, *pressedItem, *selectAnchor, *renamingItem; + QRect *rubber; + QTimer *scrollTimer, *adjustTimer, *updateTimer, *inputTimer, + *fullRedrawTimer; + int rastX, rastY, spacing; + int dragItems; + QPoint oldDragPos; + Q3IconView::Arrangement arrangement; + Q3IconView::ResizeMode resizeMode; + QSize oldSize; +#ifndef QT_NO_DRAGANDDROP + QLinkedList<Q3IconDragDataItem> iconDragData; +#endif + int numDragItems, cachedW, cachedH; + int maxItemWidth, maxItemTextLength; + QPoint dragStart; + QString currInputString; + Q3IconView::ItemTextPos itemTextPos; +#ifndef QT_NO_CURSOR + QCursor oldCursor; +#endif + int cachedContentsX, cachedContentsY; + QBrush itemTextBrush; + QRegion clipRegion; + QPoint dragStartPos; + QFontMetrics *fm; + int minLeftBearing, minRightBearing; + + uint mousePressed : 1; + uint cleared : 1; + uint dropped : 1; + uint clearing : 1; + uint oldDragAcceptAction : 1; + uint isIconDrag : 1; + uint drawDragShapes : 1; + uint dirty : 1; + uint rearrangeEnabled : 1; + uint reorderItemsWhenInsert : 1; + uint drawAllBack : 1; + uint resortItemsWhenInsert : 1; + uint sortDirection : 1; + uint wordWrapIconText : 1; + uint containerUpdateLocked : 1; + uint firstSizeHint : 1; + uint showTips : 1; + uint pressedSelected : 1; + uint dragging : 1; + uint drawActiveSelection : 1; + uint inMenuMode : 1; + + QPoint dragPos; + QPixmapCache maskCache; + QHash<Q3IconViewItem *, Q3IconViewItem *> selectedItems; + + struct ItemContainer { + ItemContainer(ItemContainer *pr, ItemContainer *nx, const QRect &r) + : p(pr), n(nx), rect(r) + { + if (p) + p->n = this; + if (n) + n->p = this; + } + ItemContainer *p, *n; + QRect rect; + QList<Q3IconViewItem*> items; + } *firstContainer, *lastContainer; + + struct SortableItem { + Q3IconViewItem *item; + }; + +public: + + /* finds the containers that intersect with \a searchRect in the direction \a dir relative to \a relativeTo */ + QList<ItemContainer* >* findContainers( + Q3IconView:: Direction dir, + const QPoint &relativeTo, + const QRect &searchRect) const; + // friend int cmpIconViewItems(const void *n1, const void *n2); +}; + + +QList<Q3IconViewPrivate::ItemContainer *>* Q3IconViewPrivate::findContainers( + Q3IconView:: Direction dir, + const QPoint &relativeTo, + const QRect &searchRect) const +{ + + QList<Q3IconViewPrivate::ItemContainer *>* list = + new QList<Q3IconViewPrivate::ItemContainer*>(); + + if (arrangement == Q3IconView::LeftToRight) { + if (dir == Q3IconView::DirLeft || dir == Q3IconView::DirRight) { + ItemContainer *c = firstContainer; + for (; c; c = c->n) + if (c->rect.intersects(searchRect)) + list->append(c); + } else { + if (dir == Q3IconView::DirDown) { + ItemContainer *c = firstContainer; + for (; c; c = c->n) + if (c->rect.intersects(searchRect) && + c->rect.bottom() >= relativeTo.y()) + list->append(c); + } else { + ItemContainer *c = lastContainer; + for (; c; c = c->p) + if (c->rect.intersects(searchRect) && + c->rect.top() <= relativeTo.y()) + list->append(c); + } + } + } else { + if (dir == Q3IconView::DirUp || dir == Q3IconView::DirDown) { + ItemContainer *c = firstContainer; + for (; c; c = c->n) + if (c->rect.intersects(searchRect)) + list->append(c); + } else { + if (dir == Q3IconView::DirRight) { + ItemContainer *c = firstContainer; + for (; c; c = c->n) + if (c->rect.intersects(searchRect) && + c->rect.right() >= relativeTo.x()) + list->append(c); + } else { + ItemContainer *c = lastContainer; + for (; c; c = c->p) + if (c->rect.intersects(searchRect) && + c->rect.left() <= relativeTo.x()) + list->append(c); + } + } + } + return list; +} + + +#if defined(Q_C_CALLBACKS) +extern "C" { +#endif + +#ifdef Q_OS_WINCE +static int _cdecl cmpIconViewItems(const void *n1, const void *n2) +#else +static int cmpIconViewItems(const void *n1, const void *n2) +#endif +{ + if (!n1 || !n2) + return 0; + + Q3IconViewPrivate::SortableItem *i1 = (Q3IconViewPrivate::SortableItem *)n1; + Q3IconViewPrivate::SortableItem *i2 = (Q3IconViewPrivate::SortableItem *)n2; + + return i1->item->compare(i2->item); +} + +#if defined(Q_C_CALLBACKS) +} +#endif + +class Q3IconViewItemPrivate +{ +public: + Q3IconViewPrivate::ItemContainer *container1, *container2; +}; + +#ifndef QT_NO_TEXTEDIT + +class Q3IconViewItemLineEdit : public Q3TextEdit +{ + friend class Q3IconViewItem; + +public: + Q3IconViewItemLineEdit(const QString &text, QWidget *parent, Q3IconViewItem *theItem, const char* name=0); + +protected: + void keyPressEvent(QKeyEvent *e); + void focusOutEvent(QFocusEvent *e); + +protected: + Q3IconViewItem *item; + QString startText; + +private: + Q_DISABLE_COPY(Q3IconViewItemLineEdit) +}; + +Q3IconViewItemLineEdit::Q3IconViewItemLineEdit(const QString &text, QWidget *parent, + Q3IconViewItem *theItem, const char *name) + : Q3TextEdit(parent, name), item(theItem), startText(text) +{ + setFrameStyle(QFrame::Plain | QFrame::Box); + setLineWidth(1); + + setHScrollBarMode(AlwaysOff); + setVScrollBarMode(AlwaysOff); + + setWordWrap(WidgetWidth); + setWrapColumnOrWidth(item->iconView()->maxItemWidth() - + (item->iconView()->itemTextPos() == Q3IconView::Bottom ? + 0 : item->pixmapRect().width())); + document()->formatter()->setAllowBreakInWords(true); + resize(200, 200); // ### some size, there should be a forceReformat() + setTextFormat(Qt::PlainText); + setText(text); + setAlignment(Qt::AlignCenter); + + resize(wrapColumnOrWidth() + 2, heightForWidth(wrapColumnOrWidth()) + 2); +} + +void Q3IconViewItemLineEdit::keyPressEvent(QKeyEvent *e) +{ + if (e->key() == Qt::Key_Escape) { + item->Q3IconViewItem::setText(startText); + item->cancelRenameItem(); + } else if (e->key() == Qt::Key_Enter || + e->key() == Qt::Key_Return) { + item->renameItem(); + } else { + Q3TextEdit::keyPressEvent(e); + sync(); + resize(width(), document()->height() + 2); + + } +} + +void Q3IconViewItemLineEdit::focusOutEvent(QFocusEvent *e) +{ + Q_UNUSED(e) // I need this to get rid of a Borland warning + if (e->reason() != Qt::PopupFocusReason) + item->cancelRenameItem(); +} +#endif + +#ifndef QT_NO_DRAGANDDROP + + +/*! + \class Q3IconDragItem + \brief The Q3IconDragItem class encapsulates a drag item. + \compat + + The Q3IconDrag class uses a list of Q3IconDragItems to support drag + and drop operations. + + In practice a Q3IconDragItem object (or an object of a class derived + from Q3IconDragItem) is created for each icon view item which is + dragged. Each of these Q3IconDragItems is stored in a Q3IconDrag + object. + + See Q3IconView::dragObject() for more information. +*/ + +/*! + Constructs a Q3IconDragItem with no data. +*/ + +Q3IconDragItem::Q3IconDragItem() +{ + ba = "no data"; +} + +/*! + Destructor. +*/ + +Q3IconDragItem::~Q3IconDragItem() +{ +} + +/*! + Returns the data contained in the Q3IconDragItem. +*/ + +QByteArray Q3IconDragItem::data() const +{ + return ba; +} + +/*! + Sets the data for the Q3IconDragItem to the data stored in the + QByteArray \a d. +*/ + +void Q3IconDragItem::setData(const QByteArray &d) +{ + ba = d; +} + +/*! + \internal +*/ + +bool Q3IconDragItem::operator==(const Q3IconDragItem &i) const +{ + return ba == i.ba; +} + +/*! + \reimp +*/ + +bool Q3IconDragDataItem::operator==(const Q3IconDragDataItem &i) const +{ + return (i.item == item && + i.data == data); +} + +/*! + \reimp +*/ + +bool Q3IconDragData::operator==(const Q3IconDragData &i) const +{ + return key_ == i.key_; +} + + +/*! + \class Q3IconDrag + \brief The Q3IconDrag class supports drag and drop operations + within a Q3IconView. + + \compat + + A Q3IconDrag object is used to maintain information about the + positions of dragged items and the data associated with them. + Q3IconViews are able to use this information to paint the dragged + items in the correct positions. Internally, Q3IconDrag stores the + data associated with drag items in Q3IconDragItem objects. + + If you want to use the extended drag and drop functionality of + Q3IconView, create a Q3IconDrag object in a reimplementation of + Q3IconView::dragObject(). Then create a Q3IconDragItem for each item + which should be dragged, set the data it represents with + Q3IconDragItem::setData(), and add each Q3IconDragItem to the drag + object using append(). + + The data in Q3IconDragItems is stored in a QByteArray and is + mime-typed (see QMimeSource and the + \link http://doc.trolltech.com/dnd.html Drag and Drop\endlink + overview). If you want to use your own mime-types derive a class + from Q3IconDrag and reimplement format(), encodedData() and + canDecode(). + + The fileiconview example program demonstrates the use of the + Q3IconDrag class including subclassing and reimplementing + dragObject(), format(), encodedData() and canDecode(). + + \sa QMimeSource::format() +*/ + +/*! + Constructs a drag object called \a name, which is a child of \a + dragSource. + + Note that the drag object will be deleted when \a dragSource is deleted. +*/ + +Q3IconDrag::Q3IconDrag(QWidget * dragSource, const char* name) + : Q3DragObject(dragSource, name) +{ + d = new Q3IconDragPrivate; +} + +/*! + Destructor. +*/ + +Q3IconDrag::~Q3IconDrag() +{ + delete d; +} + +/*! + Append the Q3IconDragItem, \a i, to the Q3IconDrag object's list of + items. You must also supply the geometry of the pixmap, \a pr, and + the textual caption, \a tr. + + \sa Q3IconDragItem +*/ + +void Q3IconDrag::append(const Q3IconDragItem &i, const QRect &pr, const QRect &tr) +{ + d->items.append(Q3IconDragDataItem(i, Q3IconDragData(pr, tr))); +} + +/*! + \reimp +*/ + +const char* Q3IconDrag::format(int i) const +{ + if (i == 0) + return "application/x-qiconlist"; + return 0; +} + +/*! + Returns the encoded data of the drag object if \a mime is + application/x-qiconlist. +*/ + +QByteArray Q3IconDrag::encodedData(const char* mime) const +{ + if (d->items.size() <= 0 || QString::fromLatin1(mime) != + QString::fromLatin1("application/x-qiconlist")) + return QByteArray(); + + QLinkedList<Q3IconDragDataItem>::ConstIterator it = d->items.begin(); + QString s; + for (; it != d->items.end(); ++it) { + QString k(QLatin1String("%1$@@$%2$@@$%3$@@$%4$@@$%5$@@$%6$@@$%7$@@$%8$@@$")); + k = k.arg((*it).item.pixmapRect().x()).arg( + (*it).item.pixmapRect().y()).arg((*it).item.pixmapRect().width()). + arg((*it).item.pixmapRect().height()).arg( + (*it).item.textRect().x()).arg((*it).item.textRect().y()). + arg((*it).item.textRect().width()).arg( + (*it).item.textRect().height()); + k += QString(QLatin1String((*it).data.data())) + QLatin1String("$@@$"); + s += k; + } + + QByteArray a; + a.resize(s.length() + 1); + memcpy(a.data(), s.latin1(), a.size()); + return a; +} + +/*! + Returns true if \a e can be decoded by the Q3IconDrag, otherwise + return false. +*/ + +bool Q3IconDrag::canDecode(QMimeSource* e) +{ + if (e->provides("application/x-qiconlist")) + return true; + return false; +} + +/*! + Decodes the data which is stored (encoded) in \a e and, if + successful, fills the \a list of icon drag items with the decoded + data. Returns true if there was some data, false otherwise. +*/ + +bool Q3IconDragPrivate::decode(QMimeSource* e, QLinkedList<Q3IconDragDataItem> &lst) +{ + QByteArray ba = e->encodedData("application/x-qiconlist"); + if (ba.size()) { + lst.clear(); + // #### unicode clean???? + QString s = QString::fromLatin1(ba); + Q3IconDragDataItem item; + QRect ir, tr; + QStringList l = QStringList::split(QLatin1String("$@@$"), s); + + int i = 0; + QStringList::Iterator it = l.begin(); + for (; it != l.end(); ++it) { + if (i == 0) { + ir.setX((*it).toInt()); + } else if (i == 1) { + ir.setY((*it).toInt()); + } else if (i == 2) { + ir.setWidth((*it).toInt()); + } else if (i == 3) { + ir.setHeight((*it).toInt()); + } else if (i == 4) { + tr.setX((*it).toInt()); + } else if (i == 5) { + tr.setY((*it).toInt()); + } else if (i == 6) { + tr.setWidth((*it).toInt()); + } else if (i == 7) { + tr.setHeight((*it).toInt()); + } else if (i == 8) { + QByteArray d; + d.resize((*it).length()); + memcpy(d.data(), (*it).latin1(), (*it).length()); + item.item.setPixmapRect(ir); + item.item.setTextRect(tr); + item.data.setData(d); + lst.append(item); + } + ++i; + if (i > 8) + i = 0; + } + return true; + } + + return false; +} + +Q3IconDragData::Q3IconDragData() + : iconRect_(), textRect_() +{ +} + +Q3IconDragData::Q3IconDragData(const QRect &ir, const QRect &tr) + : iconRect_(ir), textRect_(tr) +{ +} + +QRect Q3IconDragData::textRect() const +{ + return textRect_; +} + +QRect Q3IconDragData::pixmapRect() const +{ + return iconRect_; +} + +void Q3IconDragData::setPixmapRect(const QRect &r) +{ + iconRect_ = r; +} + +void Q3IconDragData::setTextRect(const QRect &r) +{ + textRect_ = r; +} + +#endif + + +/*! + \class Q3IconViewItem + \brief The Q3IconViewItem class provides a single item in a Q3IconView. + + \compat + + A Q3IconViewItem contains an icon, a string and optionally a sort + key, and can display itself in a Q3IconView. + + The simplest way to create a Q3IconViewItem and insert it into a + Q3IconView is to construct the item passing the constructor a + pointer to the icon view, a string and an icon: + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 0 + + By default the text of an icon view item may not be edited by the + user but calling setRenameEnabled(true) will allow the user to + perform in-place editing of the item's text. + + When the icon view is deleted all items in it are deleted + automatically. + + The Q3IconView::firstItem() and Q3IconViewItem::nextItem() functions + provide a means of iterating over all the items in a Q3IconView: + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 1 + + The item's icon view is available from iconView(), and its + position in the icon view from index(). + + The item's selection status is available from isSelected() and is + set and controlled by setSelected() and isSelectable(). + + The text and icon can be set with setText() and setPixmap() and + retrieved with text() and pixmap(). The item's sort key defaults + to text() but may be set with setKey() and retrieved with key(). + The comparison function, compare() uses key(). + + Items may be repositioned with move() and moveBy(). An item's + geometry is available from rect(), x(), y(), width(), height(), + size(), pos(), textRect() and pixmapRect(). You can also test + against the position of a point with contains() and intersects(). + + To remove an item from an icon view, just delete the item. The + Q3IconViewItem destructor removes it cleanly from its icon view. + + Because the icon view is designed to use drag-and-drop, the icon + view item also has functions for drag-and-drop which may be + reimplemented. + + The class is designed to be very similar to Q3ListView and Q3ListBox + in use, both via instantiation and subclassing. +*/ + +/*! + Constructs a Q3IconViewItem and inserts it into icon view \a parent + with no text and a default icon. +*/ + +Q3IconViewItem::Q3IconViewItem(Q3IconView *parent) + : view(parent), itemText(), itemIcon(unknown_icon) +{ + init(); +} + +/*! + Constructs a Q3IconViewItem and inserts it into the icon view \a + parent with no text and a default icon, after the icon view item + \a after. +*/ + +Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after) + : view(parent), itemText(), itemIcon(unknown_icon), + prev(0), next(0) +{ + init(after); +} + +/*! + Constructs an icon view item and inserts it into the icon view \a + parent using \a text as the text and a default icon. +*/ + +Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, const QString &text) + : view(parent), itemText(text), itemIcon(unknown_icon) +{ + init(0); +} + +/*! + Constructs an icon view item and inserts it into the icon view \a + parent using \a text as the text and a default icon, after the + icon view item \a after. +*/ + +Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after, + const QString &text) + : view(parent), itemText(text), itemIcon(unknown_icon) +{ + init(after); +} + +/*! + Constructs an icon view item and inserts it into the icon view \a + parent using \a text as the text and \a icon as the icon. +*/ + +Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, const QString &text, + const QPixmap &icon) + : view(parent), + itemText(text), itemIcon(new QPixmap(icon)) +{ + init(0); +} + + +/*! + Constructs an icon view item and inserts it into the icon view \a + parent using \a text as the text and \a icon as the icon, after + the icon view item \a after. +*/ + +Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after, + const QString &text, const QPixmap &icon) + : view(parent), itemText(text), itemIcon(new QPixmap(icon)) +{ + init(after); +} + +/*! + Constructs an icon view item and inserts it into the icon view \a + parent using \a text as the text and \a picture as the icon. +*/ + +#ifndef QT_NO_PICTURE +Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, const QString &text, + const QPicture &picture) + : view(parent), itemText(text), itemIcon(0) +{ + init(0, new QPicture(picture)); +} + +/*! + Constructs an icon view item and inserts it into the icon view \a + parent using \a text as the text and \a picture as the icon, after + the icon view item \a after. +*/ + +Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after, + const QString &text, const QPicture &picture) + : view(parent), itemText(text), itemIcon(0) +{ + init(after, new QPicture(picture)); +} +#endif + +/*! + This private function initializes the icon view item and inserts it + into the icon view. +*/ + +void Q3IconViewItem::init(Q3IconViewItem *after +#ifndef QT_NO_PICTURE + , QPicture *pic +#endif + ) +{ + d = new Q3IconViewItemPrivate; + d->container1 = 0; + d->container2 = 0; + prev = next = 0; + allow_rename = false; + allow_drag = true; + allow_drop = true; + selected = false; + selectable = true; +#ifndef QT_NO_TEXTEDIT + renameBox = 0; +#endif +#ifndef QT_NO_PICTURE + itemPic = pic; +#endif + if (view) { + itemKey = itemText; + dirty = true; + wordWrapDirty = true; + itemRect = QRect(-1, -1, 0, 0); + calcRect(); + view->insertItem(this, after); + } +} + +/*! + Destroys the icon view item and tells the parent icon view that + the item has been destroyed. +*/ + +Q3IconViewItem::~Q3IconViewItem() +{ +#ifndef QT_NO_TEXTEDIT + removeRenameBox(); +#endif + if (view && !view->d->clearing) + view->takeItem(this); + view = 0; + if (itemIcon && itemIcon->serialNumber() != unknown_icon->serialNumber()) + delete itemIcon; +#ifndef QT_NO_PICTURE + delete itemPic; +#endif + delete d; +} + +int Q3IconViewItem::RTTI = 0; + +/*! + Returns 0. + + Make your derived classes return their own values for rtti(), so + that you can distinguish between icon view item types. You should + use values greater than 1000, preferably a large random number, to + allow for extensions to this class. +*/ + +int Q3IconViewItem::rtti() const +{ + return RTTI; +} + + +/*! + Sets \a text as the text of the icon view item. This function + might be a no-op if you reimplement text(). + + \sa text() +*/ + +void Q3IconViewItem::setText(const QString &text) +{ + if (text == itemText) + return; + + wordWrapDirty = true; + itemText = text; + if (itemKey.isEmpty()) + itemKey = itemText; + + QRect oR = rect(); + calcRect(); + oR = oR.united(rect()); + + if (view) { + if (QRect(view->contentsX(), view->contentsY(), + view->visibleWidth(), view->visibleHeight()). + intersects(oR)) + view->repaintContents(oR.x() - 1, oR.y() - 1, oR.width() + 2, oR.height() + 2); + } +} + +/*! + Sets \a k as the sort key of the icon view item. By default + text() is used for sorting. + + \sa compare() +*/ + +void Q3IconViewItem::setKey(const QString &k) +{ + if (k == itemKey) + return; + + itemKey = k; +} + +/*! + Sets \a icon as the item's icon in the icon view. This function + might be a no-op if you reimplement pixmap(). + + \sa pixmap() +*/ + +void Q3IconViewItem::setPixmap(const QPixmap &icon) +{ + if (itemIcon && itemIcon == unknown_icon) + itemIcon = 0; + + if (itemIcon) + *itemIcon = icon; + else + itemIcon = new QPixmap(icon); + QRect oR = rect(); + calcRect(); + oR = oR.united(rect()); + + if (view) { + if (QRect(view->contentsX(), view->contentsY(), + view->visibleWidth(), view->visibleHeight()). + intersects(oR)) + view->repaintContents(oR.x() - 1, oR.y() - 1, oR.width() + 2, oR.height() + 2); + } +} + +/*! + Sets \a icon as the item's icon in the icon view. This function + might be a no-op if you reimplement picture(). + + \sa picture() +*/ + +#ifndef QT_NO_PICTURE +void Q3IconViewItem::setPicture(const QPicture &icon) +{ + // clear assigned pixmap if any + if (itemIcon) { + if (itemIcon == unknown_icon) { + itemIcon = 0; + } else { + delete itemIcon; + itemIcon = 0; + } + } + if (itemPic) + delete itemPic; + itemPic = new QPicture(icon); + + QRect oR = rect(); + calcRect(); + oR = oR.united(rect()); + + if (view) { + if (QRect(view->contentsX(), view->contentsY(), + view->visibleWidth(), view->visibleHeight()). + intersects(oR)) + view->repaintContents(oR.x() - 1, oR.y() - 1, oR.width() + 2, oR.height() + 2); + } +} +#endif + +/*! + \overload + + Sets \a text as the text of the icon view item. If \a recalc is + true, the icon view's layout is recalculated. If \a redraw is true + (the default), the icon view is repainted. + + \sa text() +*/ + +void Q3IconViewItem::setText(const QString &text, bool recalc, bool redraw) +{ + if (text == itemText) + return; + + wordWrapDirty = true; + itemText = text; + + if (recalc) + calcRect(); + if (redraw) + repaint(); +} + +/*! + \overload + + Sets \a icon as the item's icon in the icon view. If \a recalc is + true, the icon view's layout is recalculated. If \a redraw is true + (the default), the icon view is repainted. + + \sa pixmap() +*/ + +void Q3IconViewItem::setPixmap(const QPixmap &icon, bool recalc, bool redraw) +{ + if (itemIcon && itemIcon == unknown_icon) + itemIcon = 0; + + if (itemIcon) + *itemIcon = icon; + else + itemIcon = new QPixmap(icon); + + if (redraw) { + if (recalc) { + QRect oR = rect(); + calcRect(); + oR = oR.united(rect()); + + if (view) { + if (QRect(view->contentsX(), view->contentsY(), + view->visibleWidth(), view->visibleHeight()). + intersects(oR)) + view->repaintContents(oR.x() - 1, oR.y() - 1, oR.width() + 2, oR.height() + 2); + } + } else { + repaint(); + } + } else if (recalc) { + calcRect(); + } +} + +/*! + If \a allow is true, the user can rename the icon view item by + clicking on the text (or pressing F2) while the item is selected + (in-place renaming). If \a allow is false, in-place renaming is + not possible. +*/ + +void Q3IconViewItem::setRenameEnabled(bool allow) +{ + allow_rename = (uint)allow; +} + +/*! + If \a allow is true, the icon view permits the user to drag the + icon view item either to another position within the icon view or + to somewhere outside of it. If \a allow is false, the item cannot + be dragged. +*/ + +void Q3IconViewItem::setDragEnabled(bool allow) +{ + allow_drag = (uint)allow; +} + +/*! + If \a allow is true, the icon view lets the user drop something on + this icon view item. +*/ + +void Q3IconViewItem::setDropEnabled(bool allow) +{ + allow_drop = (uint)allow; +} + +/*! + Returns the text of the icon view item. Normally you set the text + of the item with setText(), but sometimes it's inconvenient to + call setText() for every item; so you can subclass Q3IconViewItem, + reimplement this function, and return the text of the item. If you + do this, you must call calcRect() manually each time the text + (and therefore its size) changes. + + \sa setText() +*/ + +QString Q3IconViewItem::text() const +{ + return itemText; +} + +/*! + Returns the key of the icon view item or text() if no key has been + explicitly set. + + \sa setKey(), compare() +*/ + +QString Q3IconViewItem::key() const +{ + return itemKey; +} + +/*! + Returns the icon of the icon view item if it is a pixmap, or 0 if + it is a picture. In the latter case use picture() instead. + Normally you set the pixmap of the item with setPixmap(), but + sometimes it's inconvenient to call setPixmap() for every item. So + you can subclass Q3IconViewItem, reimplement this function and + return a pointer to the item's pixmap. If you do this, you \e must + call calcRect() manually each time the size of this pixmap + changes. + + \sa setPixmap() +*/ + +QPixmap *Q3IconViewItem::pixmap() const +{ + return itemIcon; +} + +/*! + Returns the icon of the icon view item if it is a picture, or 0 if + it is a pixmap. In the latter case use pixmap() instead. Normally + you set the picture of the item with setPicture(), but sometimes + it's inconvenient to call setPicture() for every item. So you can + subclass Q3IconViewItem, reimplement this function and return a + pointer to the item's picture. If you do this, you \e must call + calcRect() manually each time the size of this picture changes. + + \sa setPicture() +*/ + +#ifndef QT_NO_PICTURE +QPicture *Q3IconViewItem::picture() const +{ + return itemPic; +} +#endif + +/*! + Returns true if the item can be renamed by the user with in-place + renaming; otherwise returns false. + + \sa setRenameEnabled() +*/ + +bool Q3IconViewItem::renameEnabled() const +{ + return (bool)allow_rename; +} + +/*! + Returns true if the user is allowed to drag the icon view item; + otherwise returns false. + + \sa setDragEnabled() +*/ + +bool Q3IconViewItem::dragEnabled() const +{ + return (bool)allow_drag; +} + +/*! + Returns true if the user is allowed to drop something onto the + item; otherwise returns false. + + \sa setDropEnabled() +*/ + +bool Q3IconViewItem::dropEnabled() const +{ + return (bool)allow_drop; +} + +/*! + Returns a pointer to this item's icon view parent. +*/ + +Q3IconView *Q3IconViewItem::iconView() const +{ + return view; +} + +/*! + Returns a pointer to the previous item, or 0 if this is the first + item in the icon view. + + \sa nextItem() Q3IconView::firstItem() +*/ + +Q3IconViewItem *Q3IconViewItem::prevItem() const +{ + return prev; +} + +/*! + Returns a pointer to the next item, or 0 if this is the last item + in the icon view. + + To find the first item use Q3IconView::firstItem(). + + Example: + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 2 + + \sa prevItem() +*/ + +Q3IconViewItem *Q3IconViewItem::nextItem() const +{ + return next; +} + +/*! + Returns the index of this item in the icon view, or -1 if an error + occurred. +*/ + +int Q3IconViewItem::index() const +{ + if (view) + return view->index(this); + + return -1; +} + + + +/*! + \overload + + This variant is equivalent to calling the other variant with \e cb + set to false. +*/ + +void Q3IconViewItem::setSelected(bool s) +{ + setSelected(s, false); +} + +/*! + Selects or unselects the item, depending on \a s; it may also + unselect other items, depending on Q3IconView::selectionMode() and + \a cb. + + If \a s is false, the item is unselected. + + If \a s is true and Q3IconView::selectionMode() is + Q3IconView::Single, the item is selected and the item previously + selected is unselected. + + If \a s is true and Q3IconView::selectionMode() is + Q3IconView::Extended, the item is selected. If \a cb is true, the + selection state of the other items is left unchanged. If \a cb is + false (the default) all other items are unselected. + + If \a s is true and Q3IconView::selectionMode() is + Q3IconView::Multi, the item is selected. + + Note that \a cb is used only if Q3IconView::selectionMode() is + Q3IconView::Extended; cb defaults to false. + + All items whose selection status changes repaint themselves. +*/ + +void Q3IconViewItem::setSelected(bool s, bool cb) +{ + if (!view) + return; + if (view->selectionMode() != Q3IconView::NoSelection && + selectable && s != (bool)selected) { + + if (view->d->selectionMode == Q3IconView::Single && this != view->d->currentItem) { + Q3IconViewItem *o = view->d->currentItem; + if (o && o->selected) + o->selected = false; + view->d->currentItem = this; + if (o) + o->repaint(); + emit view->currentChanged(this); + } + + if (!s) { + selected = false; + } else { + if (view->d->selectionMode == Q3IconView::Single && view->d->currentItem) { + view->d->currentItem->selected = false; + } + if ((view->d->selectionMode == Q3IconView::Extended && !cb) || + view->d->selectionMode == Q3IconView::Single) { + bool b = view->signalsBlocked(); + view->blockSignals(true); + view->selectAll(false); + view->blockSignals(b); + } + selected = s; + } + + repaint(); + if (!view->signalsBlocked()) { + bool emitIt = view->d->selectionMode == Q3IconView::Single && s; + Q3IconView *v = view; + emit v->selectionChanged(); + if (emitIt) + emit v->selectionChanged(this); + } + } +} + +/*! + Sets this item to be selectable if \a enable is true (the default) + or unselectable if \a enable is false. + + The user is unable to select a non-selectable item using either + the keyboard or the mouse. (The application programmer can select + an item in code regardless of this setting.) + + \sa isSelectable() +*/ + +void Q3IconViewItem::setSelectable(bool enable) +{ + selectable = (uint)enable; +} + +/*! + Returns true if the item is selected; otherwise returns false. + + \sa setSelected() +*/ + +bool Q3IconViewItem::isSelected() const +{ + return (bool)selected; +} + +/*! + Returns true if the item is selectable; otherwise returns false. + + \sa setSelectable() +*/ + +bool Q3IconViewItem::isSelectable() const +{ + return (bool)selectable; +} + +/*! + Repaints the item. +*/ + +void Q3IconViewItem::repaint() +{ + if (view) + view->repaintItem(this); +} + +/*! + Moves the item to position (\a x, \a y) in the icon view (these + are contents coordinates). Returns true if the item is moved. + Returns false if the item is already at the specified position. +*/ + +bool Q3IconViewItem::move(int x, int y) +{ + if (x == this->x() && y == this->y()) + return false; + itemRect.setRect(x, y, itemRect.width(), itemRect.height()); + checkRect(); + if (view) + view->updateItemContainer(this); + return true; +} + +/*! + Moves the item \a dx pixels in the x-direction and \a dy pixels in + the y-direction. +*/ + +void Q3IconViewItem::moveBy(int dx, int dy) +{ + itemRect.moveBy(dx, dy); + checkRect(); + if (view) + view->updateItemContainer(this); +} + +/*! + \overload + + Moves the item to the point \a pnt. +*/ + +bool Q3IconViewItem::move(const QPoint &pnt) +{ + return move(pnt.x(), pnt.y()); +} + +/*! + \overload + + Moves the item by the x, y values in point \a pnt. +*/ + +void Q3IconViewItem::moveBy(const QPoint &pnt) +{ + moveBy(pnt.x(), pnt.y()); +} + +/*! + Returns the bounding rectangle of the item (in contents + coordinates). +*/ + +QRect Q3IconViewItem::rect() const +{ + return itemRect; +} + +/*! + Returns the x-coordinate of the item (in contents coordinates). +*/ + +int Q3IconViewItem::x() const +{ + return itemRect.x(); +} + +/*! + Returns the y-coordinate of the item (in contents coordinates). +*/ + +int Q3IconViewItem::y() const +{ + return itemRect.y(); +} + +/*! + Returns the width of the item. +*/ + +int Q3IconViewItem::width() const +{ + return qMax(itemRect.width(), QApplication::globalStrut().width()); +} + +/*! + Returns the height of the item. +*/ + +int Q3IconViewItem::height() const +{ + return qMax(itemRect.height(), QApplication::globalStrut().height()); +} + +/*! + Returns the size of the item. +*/ + +QSize Q3IconViewItem::size() const +{ + return QSize(itemRect.width(), itemRect.height()); +} + +/*! + Returns the position of the item (in contents coordinates). +*/ + +QPoint Q3IconViewItem::pos() const +{ + return QPoint(itemRect.x(), itemRect.y()); +} + +/*! + Returns the bounding rectangle of the item's text. + + If \a relative is true, (the default), the returned rectangle is + relative to the origin of the item's rectangle. If \a relative is + false, the returned rectangle is relative to the origin of the + icon view's contents coordinate system. +*/ + +QRect Q3IconViewItem::textRect(bool relative) const +{ + if (relative) + return itemTextRect; + else + return QRect(x() + itemTextRect.x(), y() + itemTextRect.y(), itemTextRect.width(), itemTextRect.height()); +} + +/*! + Returns the bounding rectangle of the item's icon. + + If \a relative is true, (the default), the rectangle is relative to + the origin of the item's rectangle. If \a relative is false, the + returned rectangle is relative to the origin of the icon view's + contents coordinate system. +*/ + +QRect Q3IconViewItem::pixmapRect(bool relative) const +{ + if (relative) + return itemIconRect; + else + return QRect(x() + itemIconRect.x(), y() + itemIconRect.y(), itemIconRect.width(), itemIconRect.height()); +} + +/*! + Returns true if the item contains the point \a pnt (in contents + coordinates); otherwise returns false. +*/ + +bool Q3IconViewItem::contains(const QPoint& pnt) const +{ + QRect textArea = textRect(false); + QRect pixmapArea = pixmapRect(false); + if (iconView()->itemTextPos() == Q3IconView::Bottom) + textArea.setTop(pixmapArea.bottom()); + else + textArea.setLeft(pixmapArea.right()); + return textArea.contains(pnt) || pixmapArea.contains(pnt); +} + +/*! + Returns true if the item intersects the rectangle \a r (in + contents coordinates); otherwise returns false. +*/ + +bool Q3IconViewItem::intersects(const QRect& r) const +{ + return (textRect(false).intersects(r) || + pixmapRect(false).intersects(r)); +} + +/*! + \fn bool Q3IconViewItem::acceptDrop(const QMimeSource *mime) const + + Returns true if you can drop things with a QMimeSource of \a mime + onto this item; otherwise returns false. + + The default implementation always returns false. You must subclass + Q3IconViewItem and reimplement acceptDrop() to accept drops. +*/ + +bool Q3IconViewItem::acceptDrop(const QMimeSource *) const +{ + return false; +} + +#ifndef QT_NO_TEXTEDIT +/*! + Starts in-place renaming of an icon, if allowed. + + This function sets up the icon view so that the user can edit the + item text, and then returns. When the user is done, setText() will + be called and Q3IconView::itemRenamed() will be emitted (unless the + user canceled, e.g. by pressing the Escape key). + + \sa setRenameEnabled() +*/ + +void Q3IconViewItem::rename() +{ + if (!view) + return; + if (renameBox) + removeRenameBox(); + oldRect = rect(); + renameBox = new Q3IconViewItemLineEdit(itemText, view->viewport(), this, "qt_renamebox"); + iconView()->ensureItemVisible(this); + QRect tr(textRect(false)); + view->addChild(renameBox, tr.x() + (tr.width() / 2 - renameBox->width() / 2), tr.y() - 3); + renameBox->selectAll(); + view->viewport()->setFocusProxy(renameBox); + renameBox->setFocus(); + renameBox->show(); + Q_ASSERT(view->d->renamingItem == 0L); + view->d->renamingItem = this; +} +#endif + +/*! + Compares this icon view item to \a i. Returns -1 if this item is + less than \a i, 0 if they are equal, and 1 if this icon view item + is greater than \a i. + + The default implementation compares the item keys (key()) using + QString::localeAwareCompare(). A reimplementation may use + different values and a different comparison function. Here is a + reimplementation that uses plain Unicode comparison: + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 3 + + \sa key() QString::localeAwareCompare() QString::compare() +*/ + +int Q3IconViewItem::compare(Q3IconViewItem *i) const +{ + return key().localeAwareCompare(i->key()); +} + +#ifndef QT_NO_TEXTEDIT +/*! + This private function is called when the user pressed Return during + in-place renaming. +*/ + +void Q3IconViewItem::renameItem() +{ + if (!renameBox || !view) + return; + + if (!view->d->wordWrapIconText) { + wordWrapDirty = true; + calcRect(); + } + QRect r = itemRect; + setText(renameBox->text()); + view->repaintContents(oldRect.x() - 1, oldRect.y() - 1, oldRect.width() + 2, oldRect.height() + 2); + view->repaintContents(r.x() - 1, r.y() - 1, r.width() + 2, r.height() + 2); + removeRenameBox(); + + view->emitRenamed(this); +} + +/*! + Cancels in-place renaming. +*/ + +void Q3IconViewItem::cancelRenameItem() +{ + if (!view) + return; + + QRect r = itemRect; + calcRect(); + view->repaintContents(oldRect.x() - 1, oldRect.y() - 1, oldRect.width() + 2, oldRect.height() + 2); + view->repaintContents(r.x() - 1, r.y() - 1, r.width() + 2, r.height() + 2); + + if (!renameBox) + return; + + removeRenameBox(); +} + +/*! + Removes the editbox that is used for in-place renaming. +*/ + +void Q3IconViewItem::removeRenameBox() +{ + if (!renameBox || !view) + return; + + bool resetFocus = view->viewport()->focusProxy() == renameBox; + renameBox->hide(); + renameBox->deleteLater(); + renameBox = 0; + if (resetFocus) { + view->viewport()->setFocusProxy(view); + view->setFocus(); + } + Q_ASSERT(view->d->renamingItem == this); + view->d->renamingItem = 0L; +} +#endif + +/*! + This virtual function is responsible for calculating the + rectangles returned by rect(), textRect() and pixmapRect(). + setRect(), setTextRect() and setPixmapRect() are provided mainly + for reimplementations of this function. + + \a text_ is an internal parameter which defaults to an empty + string. +*/ + +void Q3IconViewItem::calcRect(const QString &text_) +{ + if (!view) // ##### + return; + + wordWrapDirty = true; + int pw = 0; + int ph = 0; + +#ifndef QT_NO_PICTURE + if (picture()) { + QRect br = picture()->boundingRect(); + pw = br.width() + 2; + ph = br.height() + 2; + } else +#endif + { + pw = (pixmap() ? pixmap() : unknown_icon)->width() + 2; + ph = (pixmap() ? pixmap() : unknown_icon)->height() + 2; + } + + itemIconRect.setWidth(pw); + itemIconRect.setHeight(ph); + + calcTmpText(); + + QString t = text_; + if (t.isEmpty()) { + if (view->d->wordWrapIconText) + t = itemText; + else + t = tmpText; + } + + int tw = 0; + int th = 0; + // ##### TODO: fix font bearings! + QRect r; + if (view->d->wordWrapIconText) { + r = QRect(view->d->fm->boundingRect(0, 0, iconView()->maxItemWidth() - + (iconView()->itemTextPos() == Q3IconView::Bottom ? 0 : + pixmapRect().width()), + 0xFFFFFFFF, Qt::AlignHCenter | Qt::WordBreak | Qt::BreakAnywhere, t)); + r.setWidth(r.width() + 4); + } else { + r = QRect(0, 0, view->d->fm->width(t), view->d->fm->height()); + r.setWidth(r.width() + 4); + } + + if (r.width() > iconView()->maxItemWidth() - + (iconView()->itemTextPos() == Q3IconView::Bottom ? 0 : + pixmapRect().width())) + r.setWidth(iconView()->maxItemWidth() - (iconView()->itemTextPos() == Q3IconView::Bottom ? 0 : + pixmapRect().width())); + + tw = r.width(); + th = r.height(); + if (tw < view->d->fm->width(QLatin1String("X"))) + tw = view->d->fm->width(QLatin1String("X")); + + itemTextRect.setWidth(tw); + itemTextRect.setHeight(th); + + int w = 0; + int h = 0; + if (view->itemTextPos() == Q3IconView::Bottom) { + w = qMax(itemTextRect.width(), itemIconRect.width()); + h = itemTextRect.height() + itemIconRect.height() + 1; + + itemRect.setWidth(w); + itemRect.setHeight(h); + + itemTextRect = QRect((width() - itemTextRect.width()) / 2, height() - itemTextRect.height(), + itemTextRect.width(), itemTextRect.height()); + itemIconRect = QRect((width() - itemIconRect.width()) / 2, 0, + itemIconRect.width(), itemIconRect.height()); + } else { + h = qMax(itemTextRect.height(), itemIconRect.height()); + w = itemTextRect.width() + itemIconRect.width() + 1; + + itemRect.setWidth(w); + itemRect.setHeight(h); + + itemTextRect = QRect(width() - itemTextRect.width(), (height() - itemTextRect.height()) / 2, + itemTextRect.width(), itemTextRect.height()); + itemIconRect = QRect(0, (height() - itemIconRect.height()) / 2, + itemIconRect.width(), itemIconRect.height()); + } + if (view) + view->updateItemContainer(this); +} + +/*! + Paints the item using the painter \a p and the color group \a cg. + If you want the item to be drawn with a different font or color, + reimplement this function, change the values of the color group or + the painter's font, and then call the Q3IconViewItem::paintItem() + with the changed values. +*/ + +void Q3IconViewItem::paintItem(QPainter *p, const QColorGroup &cg) +{ + if (!view) + return; + + p->save(); + + if (isSelected()) { + p->setPen(cg.highlightedText()); + } else { + p->setPen(cg.text()); + } + + calcTmpText(); + +#ifndef QT_NO_PICTURE + if (picture()) { + QPicture *pic = picture(); + if (isSelected()) { + p->fillRect(pixmapRect(false), QBrush(cg.highlight(), Qt::Dense4Pattern)); + } + p->drawPicture(x()-pic->boundingRect().x(), y()-pic->boundingRect().y(), *pic); + if (isSelected()) { + p->fillRect(textRect(false), cg.highlight()); + p->setPen(QPen(cg.highlightedText())); + } else if (view->d->itemTextBrush != QBrush(Qt::NoBrush)) + p->fillRect(textRect(false), view->d->itemTextBrush); + + int align = view->itemTextPos() == Q3IconView::Bottom ? Qt::AlignHCenter : Qt::AlignAuto; + if (view->d->wordWrapIconText) + align |= Qt::WordBreak | Qt::BreakAnywhere; + p->drawText(textRect(false), align, view->d->wordWrapIconText ? itemText : tmpText); + p->restore(); + return; + } +#endif + bool textOnBottom = (view->itemTextPos() == Q3IconView::Bottom); + int dim; + if (textOnBottom) + dim = (pixmap() ? pixmap() : unknown_icon)->width(); + else + dim = (pixmap() ? pixmap() : unknown_icon)->height(); + if (isSelected()) { + QPixmap *pix = pixmap() ? pixmap() : unknown_icon; + if (pix && !pix->isNull()) { + QPixmap *buffer = get_qiv_buffer_pixmap(pix->size()); + QBitmap mask = view->mask(pix); + + QPainter p2(buffer); + p2.fillRect(pix->rect(), Qt::white); + p2.drawPixmap(0, 0, *pix); + p2.end(); + + p2.begin(buffer); + p2.fillRect(pix->rect(), QBrush(cg.highlight(), Qt::Dense4Pattern)); + p2.end(); + buffer->setMask(mask); + + QRect cr = pix->rect(); + if (textOnBottom) + p->drawPixmap(x() + (width() - dim) / 2, y(), *buffer, 0, 0, + cr.width(), cr.height()); + else + p->drawPixmap(x() , y() + (height() - dim) / 2, *buffer, 0, 0, + cr.width(), cr.height()); + } + } else { + if (textOnBottom) + p->drawPixmap(x() + (width() - dim) / 2, y(), + *(pixmap() ? pixmap() : unknown_icon)); + else + p->drawPixmap(x() , y() + (height() - dim) / 2, + *(pixmap() ? pixmap() : unknown_icon)); + } + + p->save(); + if (isSelected()) { + p->fillRect(textRect(false), cg.highlight()); + p->setPen(QPen(cg.highlightedText())); + } else if (view->d->itemTextBrush != QBrush(Qt::NoBrush)) + p->fillRect(textRect(false), view->d->itemTextBrush); + + int align = Qt::AlignHCenter; + if (view->d->wordWrapIconText) + align |= Qt::WordBreak | Qt::BreakAnywhere; + p->drawText(textRect(false), align, + view->d->wordWrapIconText ? itemText : tmpText); + + p->restore(); + + p->restore(); +} + +/*! + Paints the focus rectangle of the item using the painter \a p and + the color group \a cg. +*/ + +void Q3IconViewItem::paintFocus(QPainter *p, const QColorGroup &cg) +{ + if (!view) + return; + + QStyleOptionFocusRect opt; + opt.rect = textRect(false); + opt.palette = cg; + if (isSelected()) { + opt.state = QStyle::State_FocusAtBorder; + opt.backgroundColor = cg.highlight(); + } else { + opt.state = QStyle::State_None; + opt.backgroundColor = cg.base(); + } + view->style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p); + + if (this != view->d->currentItem) { + opt.rect = pixmapRect(false); + opt.backgroundColor = cg.base(); + opt.state = QStyle::State_None; + view->style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p); + } +} + +#ifndef QT_NO_DRAGANDDROP +/*! + \fn void Q3IconViewItem::dropped(QDropEvent *e, const Q3ValueList<Q3IconDragItem> &lst) + + This function is called when something is dropped on the item. \a + e provides all the information about the drop. If the drag object + of the drop was a Q3IconDrag, \a lst contains the list of the + dropped items. You can get the data by calling + Q3IconDragItem::data() on each item. If the \a lst is empty, i.e. + the drag was not a Q3IconDrag, you must decode the data in \a e and + work with that. + + The default implementation does nothing; subclasses may + reimplement this function. +*/ + +void Q3IconViewItem::dropped(QDropEvent *, const Q3ValueList<Q3IconDragItem> &) +{ +} +#endif + +/*! + This function is called when a drag enters the item's bounding + rectangle. + + The default implementation does nothing; subclasses may + reimplement this function. +*/ + +void Q3IconViewItem::dragEntered() +{ +} + +/*! + This function is called when a drag leaves the item's bounding + rectangle. + + The default implementation does nothing; subclasses may + reimplement this function. +*/ + +void Q3IconViewItem::dragLeft() +{ +} + +/*! + Sets the bounding rectangle of the whole item to \a r. This + function is provided for subclasses which reimplement calcRect(), + so that they can set the calculated rectangle. \e{Any other use is + discouraged.} + + \sa calcRect() textRect() setTextRect() pixmapRect() setPixmapRect() +*/ + +void Q3IconViewItem::setItemRect(const QRect &r) +{ + itemRect = r; + checkRect(); + if (view) + view->updateItemContainer(this); +} + +/*! + Sets the bounding rectangle of the item's text to \a r. This + function is provided for subclasses which reimplement calcRect(), + so that they can set the calculated rectangle. \e{Any other use is + discouraged.} + + \sa calcRect() textRect() setItemRect() setPixmapRect() +*/ + +void Q3IconViewItem::setTextRect(const QRect &r) +{ + itemTextRect = r; + if (view) + view->updateItemContainer(this); +} + +/*! + Sets the bounding rectangle of the item's icon to \a r. This + function is provided for subclasses which reimplement calcRect(), + so that they can set the calculated rectangle. \e{Any other use is + discouraged.} + + \sa calcRect() pixmapRect() setItemRect() setTextRect() +*/ + +void Q3IconViewItem::setPixmapRect(const QRect &r) +{ + itemIconRect = r; + if (view) + view->updateItemContainer(this); +} + +/*! + \internal +*/ + +void Q3IconViewItem::calcTmpText() +{ + if (!view || view->d->wordWrapIconText || !wordWrapDirty) + return; + wordWrapDirty = false; + + int w = iconView()->maxItemWidth() - (iconView()->itemTextPos() == Q3IconView::Bottom ? 0 : + pixmapRect().width()); + if (view->d->fm->width(itemText) < w) { + tmpText = itemText; + return; + } + + tmpText = QLatin1String("..."); + int i = 0; + while (view->d->fm->width(tmpText + itemText[i]) < w) + tmpText += itemText[i++]; + tmpText.remove((uint)0, 3); + tmpText += QLatin1String("..."); +} + +/*! \internal */ + +QString Q3IconViewItem::tempText() const +{ + return tmpText; +} + +void Q3IconViewItem::checkRect() +{ + int x = itemRect.x(); + int y = itemRect.y(); + int w = itemRect.width(); + int h = itemRect.height(); + + bool changed = false; + if (x < 0) { + x = 0; + changed = true; + } + if (y < 0) { + y = 0; + changed = true; + } + + if (changed) + itemRect.setRect(x, y, w, h); +} + + +/*! + \class Q3IconView + \brief The Q3IconView class provides an area with movable labelled icons. + + \compat + + A Q3IconView can display and manage a grid or other 2D layout of + labelled icons. Each labelled icon is a Q3IconViewItem. Items + (Q3IconViewItems) can be added or deleted at any time; items can be + moved within the Q3IconView. Single or multiple items can be + selected. Items can be renamed in-place. Q3IconView also supports + \link #draganddrop drag and drop\endlink. + + Each item contains a label string, a pixmap or picture (the icon + itself) and optionally a sort key. The sort key is used for + sorting the items and defaults to the label string. The label + string can be displayed below or to the right of the icon (see \l + ItemTextPos). + + The simplest way to create a Q3IconView is to create a Q3IconView + object and create some Q3IconViewItems with the Q3IconView as their + parent, set the icon view's geometry and show it. + For example: + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 4 + + The Q3IconViewItem call passes a pointer to the Q3IconView we wish to + populate, along with the label text and a QPixmap. + + When an item is inserted the Q3IconView allocates a position for it. + Existing items are rearranged if autoArrange() is true. The + default arrangement is \l LeftToRight -- the Q3IconView fills up + the \e left-most column from top to bottom, then moves one column + \e right and fills that from top to bottom and so on. The + arrangement can be modified with any of the following approaches: + \list + \i Call setArrangement(), e.g. with \l TopToBottom which will fill + the \e top-most row from left to right, then moves one row \e down + and fills that row from left to right and so on. + \i Construct each Q3IconViewItem using a constructor which allows + you to specify which item the new one is to follow. + \i Call setSorting() or sort() to sort the items. + \endlist + + The spacing between items is set with setSpacing(). Items can be + laid out using a fixed grid using setGridX() and setGridY(); by + default the Q3IconView calculates a grid dynamically. The position + of items' label text is set with setItemTextPos(). The text's + background can be set with setItemTextBackground(). The maximum + width of an item and of its text are set with setMaxItemWidth() + and setMaxItemTextLength(). The label text will be word-wrapped if + it is too long; this is controlled by setWordWrapIconText(). If + the label text is truncated, the user can still see the entire + text in a tool tip if they hover the mouse over the item. This is + controlled with setShowToolTips(). + + Items which are \link Q3IconViewItem::isSelectable() + selectable\endlink may be selected depending on the SelectionMode; + the default is \l Single. Because Q3IconView offers multiple + selection it must display keyboard focus and selection state + separately. Therefore there are functions to set the selection + state of an item (setSelected()) and to select which item displays + keyboard focus (setCurrentItem()). When multiple items may be + selected the icon view provides a rubberband, too. + + When in-place renaming is enabled (it is disabled by default), the + user may change the item's label. They do this by selecting the item + (single clicking it or navigating to it with the arrow keys), then + single clicking it (or pressing F2), and entering their text. If no + key has been set with Q3IconViewItem::setKey() the new text will also + serve as the key. (See Q3IconViewItem::setRenameEnabled().) + + You can control whether users can move items themselves with + setItemsMovable(). + + Because the internal structure used to store the icon view items is + linear, no iterator class is needed to iterate over all the items. + Instead we iterate by getting the first item from the \e{icon view} + and then each subsequent (\l Q3IconViewItem::nextItem()) from each + \e item in turn: + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 5 + Q3IconView also provides currentItem(). You can search for an item + using findItem() (searching by position or for label text) and + with findFirstVisibleItem() and findLastVisibleItem(). The number + of items is returned by count(). An item can be removed from an + icon view using takeItem(); to delete an item use \c delete. All + the items can be deleted with clear(). + + The Q3IconView emits a wide range of useful signals, including + selectionChanged(), currentChanged(), clicked(), moved() and + itemRenamed(). + + \target draganddrop + \section1 Drag and Drop + + Q3IconView supports the drag and drop of items within the Q3IconView + itself. It also supports the drag and drop of items out of or into + the Q3IconView and drag and drop onto items themselves. The drag and + drop of items outside the Q3IconView can be achieved in a simple way + with basic functionality, or in a more sophisticated way which + provides more power and control. + + The simple approach to dragging items out of the icon view is to + subclass Q3IconView and reimplement Q3IconView::dragObject(). + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 6 + + In this example we create a Q3TextDrag object, (derived from + Q3DragObject), containing the item's label and return it as the drag + object. We could just as easily have created a Q3ImageDrag from the + item's pixmap and returned that instead. + + Q3IconViews and their Q3IconViewItems can also be the targets of drag + and drops. To make the Q3IconView itself able to accept drops connect + to the dropped() signal. When a drop occurs this signal will be + emitted with a QDragEvent and a QLinkedList of Q3IconDragItems. To + make a Q3IconViewItem into a drop target subclass Q3IconViewItem and + reimplement Q3IconViewItem::acceptDrop() and + Q3IconViewItem::dropped(). + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 7 + + If you want to use extended drag-and-drop or have drag shapes drawn + you must take a more sophisticated approach. + + The first part is starting drags -- you should use a Q3IconDrag (or a + class derived from it) for the drag object. In dragObject() create the + drag object, populate it with Q3IconDragItems and return it. Normally + such a drag should offer each selected item's data. So in dragObject() + you should iterate over all the items, and create a Q3IconDragItem for + each selected item, and append these items with Q3IconDrag::append() to + the Q3IconDrag object. You can use Q3IconDragItem::setData() to set the + data of each item that should be dragged. If you want to offer the + data in additional mime-types, it's best to use a class derived from + Q3IconDrag, which implements additional encoding and decoding + functions. + + When a drag enters the icon view, there is little to do. Simply + connect to the dropped() signal and reimplement + Q3IconViewItem::acceptDrop() and Q3IconViewItem::dropped(). If you've + used a Q3IconDrag (or a subclass of it) the second argument to the + dropped signal contains a QLinkedList of Q3IconDragItems -- you can + access their data by calling Q3IconDragItem::data() on each one. + + For an example implementation of complex drag-and-drop look at the + fileiconview example (qt/examples/fileiconview). + + \sa Q3IconViewItem::setDragEnabled(), Q3IconViewItem::setDropEnabled(), + Q3IconViewItem::acceptDrop(), Q3IconViewItem::dropped() +*/ + +/*! \enum Q3IconView::ResizeMode + + This enum type is used to tell Q3IconView how it should treat the + positions of its icons when the widget is resized. The modes are: + + \value Fixed The icons' positions are not changed. + \value Adjust The icons' positions are adjusted to be within the + new geometry, if possible. +*/ + +/*! + \enum Q3IconView::SelectionMode + + This enumerated type is used by Q3IconView to indicate how it + reacts to selection by the user. It has four values: + + \value Single When the user selects an item, any already-selected + item becomes unselected and the user cannot unselect the selected + item. This means that the user can never clear the selection. (The + application programmer can, using Q3IconView::clearSelection().) + + \value Multi When the user selects an item, e.g. by navigating to + it with the keyboard arrow keys or by clicking it, the selection + status of that item is toggled and the other items are left alone. + + \value Extended When the user selects an item the selection is + cleared and the new item selected. However, if the user presses + the Ctrl key when clicking on an item, the clicked item gets + toggled and all other items are left untouched. If the user + presses the Shift key while clicking on an item, all items between + the current item and the clicked item get selected or unselected, + depending on the state of the clicked item. Also, multiple items + can be selected by dragging the mouse while the left mouse button + stays pressed. + + \value NoSelection Items cannot be selected. + + To summarize: \c Single is a real single-selection icon view; \c + Multi a real multi-selection icon view; \c Extended is an icon + view in which users can select multiple items but usually want to + select either just one or a range of contiguous items; and \c + NoSelection mode is for an icon view where the user can look but + not touch. +*/ + +/*! + \enum Q3IconView::Arrangement + + This enum type determines in which direction the items flow when + the view runs out of space. + + \value LeftToRight Items which don't fit into the view go further + down (you get a vertical scroll bar) + + \value TopToBottom Items which don't fit into the view go further + right (you get a horizontal scroll bar) +*/ + +/*! + \enum Q3IconView::ItemTextPos + + This enum type specifies the position of the item text in relation + to the icon. + + \value Bottom The text is drawn below the icon. + \value Right The text is drawn to the right of the icon. +*/ + +/*! + \fn void Q3IconView::dropped(QDropEvent *e, const Q3ValueList<Q3IconDragItem> &lst) + + This signal is emitted when a drop event occurs in the viewport + (but not on any icon) which the icon view itself can't handle. + + \a e provides all the information about the drop. If the drag + object of the drop was a Q3IconDrag, \a lst contains the list of + the dropped items. You can get the data using + Q3IconDragItem::data() on each item. If the \a lst is empty, i.e. + the drag was not a Q3IconDrag, you have to decode the data in \a e + and work with that. + + Note Q3IconViewItems may be drop targets; if a drop event occurs on + an item the item handles the drop. +*/ + +/*! + \fn void Q3IconView::moved() + + This signal is emitted after successfully dropping one (or more) + items of the icon view. If the items should be removed, it's best + to do so in a slot connected to this signal. +*/ + +/*! + \fn void Q3IconView::doubleClicked(Q3IconViewItem * item) + + This signal is emitted when the user double-clicks on \a item. +*/ + +/*! + \fn void Q3IconView::returnPressed (Q3IconViewItem * item) + + This signal is emitted if the user presses the Return or Enter + key. \a item is the currentItem() at the time of the keypress. +*/ + +/*! + \fn void Q3IconView::selectionChanged() + + This signal is emitted when the selection has been changed. It's + emitted in each selection mode. +*/ + +/*! + \fn void Q3IconView::selectionChanged(Q3IconViewItem *item) + \overload + + This signal is emitted when the selection changes. \a item is the + newly selected item. This signal is emitted only in single + selection mode. +*/ + +/*! + \fn void Q3IconView::currentChanged(Q3IconViewItem *item) + + This signal is emitted when a new item becomes current. \a item is + the new current item (or 0 if no item is now current). + + \sa currentItem() +*/ + +/*! + \fn void Q3IconView::onItem(Q3IconViewItem *item) + + This signal is emitted when the user moves the mouse cursor onto + an \a item, similar to the QWidget::enterEvent() function. +*/ + +// ### bug here - enter/leave event aren't considered. move the mouse +// out of the window and back in, to the same item. + +/*! + \fn void Q3IconView::onViewport() + + This signal is emitted when the user moves the mouse cursor from + an item to an empty part of the icon view. + + \sa onItem() +*/ + +/*! + \fn void Q3IconView::itemRenamed (Q3IconViewItem * item) + \overload + + This signal is emitted when \a item has been renamed, usually by + in-place renaming. + + \sa Q3IconViewItem::setRenameEnabled() Q3IconViewItem::rename() +*/ + +/*! + \fn void Q3IconView::itemRenamed (Q3IconViewItem * item, const QString &name) + + This signal is emitted when \a item has been renamed to \a name, + usually by in-place renaming. + + \sa Q3IconViewItem::setRenameEnabled() Q3IconViewItem::rename() +*/ + +/*! + \fn void Q3IconView::rightButtonClicked (Q3IconViewItem * item, const QPoint & pos) + + This signal is emitted when the user clicks the right mouse + button. If \a item is non-null, the cursor is on \a item. If \a + item is null, the mouse cursor isn't on any item. + + \a pos is the position of the mouse cursor in the global + coordinate system (QMouseEvent::globalPos()). (If the click's + press and release differ by a pixel or two, \a pos is the + position at release time.) + + \sa rightButtonPressed() mouseButtonClicked() clicked() +*/ + +/*! + \fn void Q3IconView::contextMenuRequested(Q3IconViewItem *item, const QPoint & pos) + + This signal is emitted when the user invokes a context menu with + the right mouse button or with special system keys, with \a item + being the item under the mouse cursor or the current item, + respectively. + + \a pos is the position for the context menu in the global + coordinate system. +*/ + +/*! + \fn void Q3IconView::mouseButtonPressed(int button, Q3IconViewItem *item, const QPoint &pos) + + This signal is emitted when the user presses mouse button \a + button. If \a item is non-null, the cursor is on \a item. If \a + item is null, the mouse cursor isn't on any item. + + \a pos is the position of the mouse cursor in the global + coordinate system (QMouseEvent::globalPos()). + + \sa rightButtonClicked() mouseButtonClicked() pressed() +*/ + +/*! + \fn void Q3IconView::mouseButtonClicked (int button, Q3IconViewItem * item, const QPoint & pos) + + This signal is emitted when the user clicks mouse button \a + button. If \a item is non-null, the cursor is on \a item. If \a + item is null, the mouse cursor isn't on any item. + + \a pos is the position of the mouse cursor in the global + coordinate system (QMouseEvent::globalPos()). (If the click's + press and release differ by a pixel or two, \a pos is the + position at release time.) + + \sa mouseButtonPressed() rightButtonClicked() clicked() +*/ + +/*! + \fn void Q3IconView::clicked (Q3IconViewItem * item, const QPoint & pos) + \overload + + This signal is emitted when the user clicks any mouse button on an + icon view item. \a item is a pointer to the item that has been + clicked. + + \a pos is the position of the mouse cursor in the global coordinate + system (QMouseEvent::globalPos()). (If the click's press and release + differ by a pixel or two, \a pos is the position at release time.) + + \sa mouseButtonClicked() rightButtonClicked() pressed() +*/ + +/*! + \fn void Q3IconView::pressed (Q3IconViewItem * item, const QPoint & pos) + \overload + + This signal is emitted when the user presses any mouse button. If + \a item is non-null, the cursor is on \a item. If \a item is null, + the mouse cursor isn't on any item. + + \a pos is the position of the mouse cursor in the global + coordinate system (QMouseEvent::globalPos()). (If the click's + press and release differ by a pixel or two, \a pos is the + position at release time.) + + \sa mouseButtonPressed() rightButtonPressed() clicked() +*/ + +/*! + \fn void Q3IconView::clicked (Q3IconViewItem * item) + + This signal is emitted when the user clicks any mouse button. If + \a item is non-null, the cursor is on \a item. If \a item is null, + the mouse cursor isn't on any item. + + \sa mouseButtonClicked() rightButtonClicked() pressed() +*/ + +/*! + \fn void Q3IconView::pressed (Q3IconViewItem * item) + + This signal is emitted when the user presses any mouse button. If + \a item is non-null, the cursor is on \a item. If \a item is null, + the mouse cursor isn't on any item. + + \sa mouseButtonPressed() rightButtonPressed() clicked() +*/ + +/*! + \fn void Q3IconView::rightButtonPressed(Q3IconViewItem * item, const QPoint & pos) + + This signal is emitted when the user presses the right mouse + button. If \a item is non-null, the cursor is on \a item. If \a + item is null, the mouse cursor isn't on any item. + + \a pos is the position of the mouse cursor in the global + coordinate system (QMouseEvent::globalPos()). +*/ + +/*! + Constructs an empty icon view called \a name, with parent \a + parent and using the widget flags \a f. +*/ + +Q3IconView::Q3IconView(QWidget *parent, const char *name, Qt::WindowFlags f) + : Q3ScrollView(parent, name, Qt::WStaticContents | Qt::WNoAutoErase | f) +{ + if (!unknown_icon) { + unknown_icon = new QPixmap((const char **)unknown_xpm); + qiv_cleanup_pixmap.add(&unknown_icon); + } + + d = new Q3IconViewPrivate; + d->dragging = false; + d->firstItem = 0; + d->lastItem = 0; + d->count = 0; + d->mousePressed = false; + d->selectionMode = Single; + d->currentItem = 0; + d->highlightedItem = 0; + d->rubber = 0; + d->scrollTimer = 0; + d->startDragItem = 0; + d->tmpCurrentItem = 0; + d->rastX = d->rastY = -1; + d->spacing = 5; + d->cleared = false; + d->arrangement = LeftToRight; + d->resizeMode = Fixed; + d->dropped = false; + d->adjustTimer = new QTimer(this, "iconview adjust timer"); + d->isIconDrag = false; + d->inMenuMode = false; +#ifndef QT_NO_DRAGANDDROP + d->iconDragData.clear(); +#endif + d->numDragItems = 0; + d->updateTimer = new QTimer(this, "iconview update timer"); + d->cachedW = d->cachedH = 0; + d->maxItemWidth = 100; + d->maxItemTextLength = 255; + d->inputTimer = new QTimer(this, "iconview input timer"); + d->currInputString.clear(); + d->dirty = false; + d->rearrangeEnabled = true; + d->itemTextPos = Bottom; + d->reorderItemsWhenInsert = true; +#ifndef QT_NO_CURSOR + d->oldCursor = Qt::ArrowCursor; +#endif + d->resortItemsWhenInsert = false; + d->sortDirection = true; + d->wordWrapIconText = true; + d->cachedContentsX = d->cachedContentsY = -1; + d->clearing = false; + d->fullRedrawTimer = new QTimer(this, "iconview full redraw timer"); + d->itemTextBrush = Qt::NoBrush; + d->drawAllBack = true; + d->fm = new QFontMetrics(font()); + d->minLeftBearing = d->fm->minLeftBearing(); + d->minRightBearing = d->fm->minRightBearing(); + d->firstContainer = d->lastContainer = 0; + d->containerUpdateLocked = false; + d->firstSizeHint = false; + d->selectAnchor = 0; + d->renamingItem = 0; + d->drawActiveSelection = true; + d->drawDragShapes = false; + + connect(d->adjustTimer, SIGNAL(timeout()), + this, SLOT(adjustItems())); + connect(d->updateTimer, SIGNAL(timeout()), + this, SLOT(slotUpdate())); + connect(d->fullRedrawTimer, SIGNAL(timeout()), + this, SLOT(updateContents())); + connect(this, SIGNAL(contentsMoving(int,int)), + this, SLOT(movedContents(int,int))); + + setAcceptDrops(true); + viewport()->setAcceptDrops(true); + + setMouseTracking(true); + viewport()->setMouseTracking(true); + + viewport()->setBackgroundRole(QPalette::Base); + viewport()->setFocusProxy(this); + viewport()->setFocusPolicy(Qt::WheelFocus); + setFocusPolicy(Qt::WheelFocus); + + d->showTips = true; +} + +/*! + \reimp +*/ +void Q3IconView::changeEvent(QEvent *ev) +{ + if(ev->type() == QEvent::StyleChange) { + *d->fm = QFontMetrics(font()); + d->minLeftBearing = d->fm->minLeftBearing(); + d->minRightBearing = d->fm->minRightBearing(); + + Q3IconViewItem *item = d->firstItem; + for (; item; item = item->next) { + item->wordWrapDirty = true; + item->calcRect(); + } + +#if !defined(Q_WS_X11) + delete qiv_selection; + qiv_selection = 0; +#endif + } else if(ev->type() == QEvent::ActivationChange) { + if (!isActiveWindow() && d->scrollTimer) + d->scrollTimer->stop(); + if(isVisible() && !palette().isEqual(QPalette::Active, QPalette::Inactive)) + repaintSelectedItems(); + } + + Q3ScrollView::changeEvent(ev); + + if (ev->type() == QEvent::ApplicationFontChange || ev->type() == QEvent::FontChange) { + *d->fm = QFontMetrics(font()); + d->minLeftBearing = d->fm->minLeftBearing(); + d->minRightBearing = d->fm->minRightBearing(); + + Q3IconViewItem *item = d->firstItem; + for (; item; item = item->next) { + item->wordWrapDirty = true; + item->calcRect(); + } + } +} + +/*! + Destroys the icon view and deletes all items. +*/ + +Q3IconView::~Q3IconView() +{ + Q3IconViewItem *tmp, *item = d->firstItem; + d->clearing = true; + Q3IconViewPrivate::ItemContainer *c = d->firstContainer, *tmpc; + while (c) { + tmpc = c->n; + delete c; + c = tmpc; + } + while (item) { + tmp = item->next; + delete item; + item = tmp; + } + delete d->fm; + d->fm = 0; + delete d; +} + +/*! + Inserts the icon view item \a item after \a after. If \a after is + 0, \a item is appended after the last item. + + \e{You should never need to call this function.} Instead create + Q3IconViewItem's and associate them with your icon view like this: + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 8 +*/ + +void Q3IconView::insertItem(Q3IconViewItem *item, Q3IconViewItem *after) +{ + if (!item) + return; + + if (d->firstItem == item || item->prev || item->next) + return; + + if (!item->view) + item->view = this; + + if (!d->firstItem) { + d->firstItem = d->lastItem = item; + item->prev = 0; + item->next = 0; + } else { + if (!after || after == d->lastItem) { + d->lastItem->next = item; + item->prev = d->lastItem; + item->next = 0; + d->lastItem = item; + } else { + Q3IconViewItem *i = d->firstItem; + while (i != after) + i = i->next; + + if (i) { + Q3IconViewItem *next = i->next; + item->next = next; + item->prev = i; + i->next = item; + next->prev = item; + } + } + } + + if (isVisible()) { + if (d->reorderItemsWhenInsert) { + if (d->updateTimer->isActive()) + d->updateTimer->stop(); + d->fullRedrawTimer->stop(); + // #### uncomment this ASA insertInGrid uses cached values and is efficient + //insertInGrid(item); + + d->cachedW = qMax(d->cachedW, item->x() + item->width()); + d->cachedH= qMax(d->cachedH, item->y() + item->height()); + + d->updateTimer->start(0, true); + } else { + insertInGrid(item); + + viewport()->update(item->x() - contentsX(), + item->y() - contentsY(), + item->width(), item->height()); + } + } else if (!autoArrange()) { + item->dirty = false; + } + + d->count++; + d->dirty = true; +} + +/*! + This slot is used for a slightly-delayed update. + + The icon view is not redrawn immediately after inserting a new item + but after a very small delay using a QTimer. This means that when + many items are inserted in a loop the icon view is probably redrawn + only once at the end of the loop. This makes the insertions both + flicker-free and faster. +*/ + +void Q3IconView::slotUpdate() +{ + d->updateTimer->stop(); + d->fullRedrawTimer->stop(); + + if (!d->firstItem || !d->lastItem) + return; + + // #### remove that ASA insertInGrid uses cached values and is efficient + if (d->resortItemsWhenInsert) + sort(d->sortDirection); + else { + int y = d->spacing; + Q3IconViewItem *item = d->firstItem; + int w = 0, h = 0; + while (item) { + bool changed; + Q3IconViewItem *next = makeRowLayout(item, y, changed); + if (!next || !next->next) + break; + + if(!QApplication::reverseLayout()) + item = next; + w = qMax(w, item->x() + item->width()); + h = qMax(h, item->y() + item->height()); + item = next; + if (d->arrangement == LeftToRight) + h = qMax(h, y); + + item = item->next; + } + + if (d->lastItem && d->arrangement == TopToBottom) { + item = d->lastItem; + int x = item->x(); + while (item && item->x() >= x) { + w = qMax(w, item->x() + item->width()); + h = qMax(h, item->y() + item->height()); + item = item->prev; + } + } + + w = qMax(qMax(d->cachedW, w), d->lastItem->x() + d->lastItem->width()); + h = qMax(qMax(d->cachedH, h), d->lastItem->y() + d->lastItem->height()); + + if (d->arrangement == TopToBottom) + w += d->spacing; + else + h += d->spacing; + viewport()->setUpdatesEnabled(false); + resizeContents(w, h); + viewport()->setUpdatesEnabled(true); + viewport()->repaint(); + } + + int cx = d->cachedContentsX == -1 ? contentsX() : d->cachedContentsX; + int cy = d->cachedContentsY == -1 ? contentsY() : d->cachedContentsY; + + if (cx != contentsX() || cy != contentsY()) + setContentsPos(cx, cy); + + d->cachedContentsX = d->cachedContentsY = -1; + d->cachedW = d->cachedH = 0; +} + +/*! + Takes the icon view item \a item out of the icon view and causes + an update of the screen display. The item is not deleted. You + should normally not need to call this function because + Q3IconViewItem::~Q3IconViewItem() calls it. The normal way to delete + an item is to delete it. +*/ + +void Q3IconView::takeItem(Q3IconViewItem *item) +{ + if (!item) + return; + + if (item->d->container1) + item->d->container1->items.removeAll(item); + if (item->d->container2) + item->d->container2->items.removeAll(item); + item->d->container2 = 0; + item->d->container1 = 0; + + bool block = signalsBlocked(); + blockSignals(d->clearing); + + QRect r = item->rect(); + + if (d->currentItem == item) { + if (item->prev) { + d->currentItem = item->prev; + emit currentChanged(d->currentItem); + repaintItem(d->currentItem); + } else if (item->next) { + d->currentItem = item->next; + emit currentChanged(d->currentItem); + repaintItem(d->currentItem); + } else { + d->currentItem = 0; + emit currentChanged(d->currentItem); + } + } + if (item->isSelected()) { + item->selected = false; + emit selectionChanged(); + } + + if (item == d->firstItem) { + d->firstItem = d->firstItem->next; + if (d->firstItem) + d->firstItem->prev = 0; + } else if (item == d->lastItem) { + d->lastItem = d->lastItem->prev; + if (d->lastItem) + d->lastItem->next = 0; + } else { + Q3IconViewItem *i = item; + if (i) { + if (i->prev) + i->prev->next = i->next; + if (i->next) + i->next->prev = i->prev; + } + } + + if (d->selectAnchor == item) + d->selectAnchor = d->currentItem; + + if (!d->clearing) + repaintContents(r.x(), r.y(), r.width(), r.height()); + + item->view = 0; + item->prev = 0; + item->next = 0; + d->count--; + + blockSignals(block); +} + +/*! + Returns the index of \a item, or -1 if \a item doesn't exist in + this icon view. +*/ + +int Q3IconView::index(const Q3IconViewItem *item) const +{ + if (!item) + return -1; + + if (item == d->firstItem) + return 0; + else if (item == d->lastItem) + return d->count - 1; + else { + Q3IconViewItem *i = d->firstItem; + int j = 0; + while (i && i != item) { + i = i->next; + ++j; + } + + return i ? j : -1; + } +} + +/*! + Returns a pointer to the first item of the icon view, or 0 if + there are no items in the icon view. + + \sa lastItem() currentItem() +*/ + +Q3IconViewItem *Q3IconView::firstItem() const +{ + return d->firstItem; +} + +/*! + Returns a pointer to the last item of the icon view, or 0 if there + are no items in the icon view. + + \sa firstItem() currentItem() +*/ + +Q3IconViewItem *Q3IconView::lastItem() const +{ + return d->lastItem; +} + +/*! + Returns a pointer to the current item of the icon view, or 0 if no + item is current. + + \sa setCurrentItem() firstItem() lastItem() +*/ + +Q3IconViewItem *Q3IconView::currentItem() const +{ + return d->currentItem; +} + +/*! + \reimp +*/ +QVariant Q3IconView::inputMethodQuery(Qt::InputMethodQuery query) const +{ + if (query == Qt::ImMicroFocus) { + return d->currentItem ? d->currentItem->rect() : QRect(); + } + return QWidget::inputMethodQuery(query); +} + +/*! + Makes \a item the new current item of the icon view. +*/ + +void Q3IconView::setCurrentItem(Q3IconViewItem *item) +{ + if (!item || item == d->currentItem) + return; + + Q3IconViewItem *old = d->currentItem; + d->currentItem = item; + emit currentChanged(d->currentItem); + if (d->selectionMode == Single) { + bool changed = false; + if (old && old->selected) { + old->selected = false; + changed = true; + } + if (item && !item->selected && item->isSelectable() && d->selectionMode != NoSelection) { + item->selected = true; + changed = true; + emit selectionChanged(item); + } + if (changed) + emit selectionChanged(); + } + + if (old) + repaintItem(old); + repaintItem(d->currentItem); +} + +/*! + Selects or unselects \a item depending on \a s, and may also + unselect other items, depending on Q3IconView::selectionMode() and + \a cb. + + If \a s is false, \a item is unselected. + + If \a s is true and Q3IconView::selectionMode() is \l Single, \a + item is selected, and the item which was selected is unselected. + + If \a s is true and Q3IconView::selectionMode() is \l Extended, \a + item is selected. If \a cb is true, the selection state of the + icon view's other items is left unchanged. If \a cb is false (the + default) all other items are unselected. + + If \a s is true and Q3IconView::selectionMode() is \l Multi \a item + is selected. + + Note that \a cb is used only if Q3IconView::selectionMode() is \l + Extended. \a cb defaults to false. + + All items whose selection status is changed repaint themselves. +*/ + +void Q3IconView::setSelected(Q3IconViewItem *item, bool s, bool cb) +{ + if (!item) + return; + item->setSelected(s, cb); +} + +/*! + \property Q3IconView::count + \brief the number of items in the icon view +*/ + +uint Q3IconView::count() const +{ + return d->count; +} + +/*! + Performs autoscrolling when selecting multiple icons with the + rubber band. +*/ + +void Q3IconView::doAutoScroll() +{ + QRect oldRubber = QRect(*d->rubber); + + QPoint vp = viewport()->mapFromGlobal(QCursor::pos()); + QPoint pos = viewportToContents(vp); + + if (pos == d->rubber->bottomRight()) + return; + + d->rubber->setRight(pos.x()); + d->rubber->setBottom(pos.y()); + + int minx = contentsWidth(), miny = contentsHeight(); + int maxx = 0, maxy = 0; + bool changed = false; + bool block = signalsBlocked(); + + QRect rr; + QRegion region(0, 0, visibleWidth(), visibleHeight()); + + blockSignals(true); + viewport()->setUpdatesEnabled(false); + bool alreadyIntersected = false; + QRect nr = d->rubber->normalized(); + QRect rubberUnion = nr.united(oldRubber.normalized()); + Q3IconViewPrivate::ItemContainer *c = d->firstContainer; + for (; c; c = c->n) { + if (c->rect.intersects(rubberUnion)) { + alreadyIntersected = true; + for (int i = 0; i < c->items.size(); ++i) { + Q3IconViewItem *item = c->items.at(i); + if (d->selectedItems.contains(item)) + continue; + if (!item->intersects(nr)) { + if (item->isSelected()) { + item->setSelected(false); + changed = true; + rr = rr.united(item->rect()); + } + } else if (item->intersects(nr)) { + if (!item->isSelected() && item->isSelectable()) { + item->setSelected(true, true); + changed = true; + rr = rr.united(item->rect()); + } else { + region = region.subtracted(QRect(contentsToViewport(item->pos()), + item->size())); + } + + minx = qMin(minx, item->x() - 1); + miny = qMin(miny, item->y() - 1); + maxx = qMax(maxx, item->x() + item->width() + 1); + maxy = qMax(maxy, item->y() + item->height() + 1); + } + } + } else { + if (alreadyIntersected) + break; + } + } + viewport()->setUpdatesEnabled(true); + blockSignals(block); + + QRect r = *d->rubber; + *d->rubber = oldRubber; + d->dragging = false; + *d->rubber = r; + if (changed) { + d->drawAllBack = false; + d->clipRegion = region; + repaintContents(rr); + d->drawAllBack = true; + } + ensureVisible(pos.x(), pos.y()); + d->dragging = true; + + if (changed) { + emit selectionChanged(); + if (d->selectionMode == Single) + emit selectionChanged(d->currentItem); + } + + if (!QRect(50, 50, viewport()->width()-100, viewport()->height()-100).contains(vp) && + !d->scrollTimer) { + d->scrollTimer = new QTimer(this); + + connect(d->scrollTimer, SIGNAL(timeout()), + this, SLOT(doAutoScroll())); + d->scrollTimer->start(100, false); + } else if (QRect(50, 50, viewport()->width()-100, viewport()->height()-100).contains(vp) && + d->scrollTimer) { + disconnect(d->scrollTimer, SIGNAL(timeout()), + this, SLOT(doAutoScroll())); + d->scrollTimer->stop(); + delete d->scrollTimer; + d->scrollTimer = 0; + } + +} + +/*! + \reimp +*/ + +void Q3IconView::drawContents(QPainter *p, int cx, int cy, int cw, int ch) +{ + if (d->dragging && d->rubber) + drawRubber(p); + + QRect r = QRect(cx, cy, cw, ch); + + Q3IconViewPrivate::ItemContainer *c = d->firstContainer; + QRegion remaining(QRect(cx, cy, cw, ch)); + bool alreadyIntersected = false; + while (c) { + if (c->rect.intersects(r)) { + p->save(); + p->resetXForm(); + QRect r2 = c->rect; + r2 = r2.intersected(r); + QRect r3(contentsToViewport(QPoint(r2.x(), r2.y())), QSize(r2.width(), r2.height())); + if (d->drawAllBack) { + p->setClipRect(r3); + } else { + QRegion reg = d->clipRegion.intersected(r3); + p->setClipRegion(reg); + } + drawBackground(p, r3); + remaining = remaining.subtracted(r3); + p->restore(); + + QPalette pal = palette(); + d->drawActiveSelection = hasFocus() || d->inMenuMode + || !style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this); + if (!d->drawActiveSelection) + pal.setCurrentColorGroup(QPalette::Inactive); + + // clip items to the container rect by default... this + // prevents icons with alpha channels from being painted + // twice when they are in 2 containers + // + // NOTE: the item could override this cliprect in its + // paintItem() implementation, which makes this useless + p->setClipRect(r2); + for (int i = 0; i < c->items.size(); ++i) { + Q3IconViewItem *item = c->items.at(i); + if (item->rect().intersects(r) && !item->dirty) { + p->save(); + p->setFont(font()); + item->paintItem(p, pal); + p->restore(); + } + } + alreadyIntersected = true; + } else { + if (alreadyIntersected) + break; + } + c = c->n; + } + + if (!remaining.isEmpty()) { + p->save(); + p->resetXForm(); + if (d->drawAllBack) { + p->setClipRegion(remaining); + } else { + remaining = d->clipRegion.intersected(remaining); + p->setClipRegion(remaining); + } + drawBackground(p, remaining.boundingRect()); + p->restore(); + } + + if ((hasFocus() || viewport()->hasFocus()) && d->currentItem && + d->currentItem->rect().intersects(r)) { + d->currentItem->paintFocus(p, palette()); + } + + if (d->dragging && d->rubber) + drawRubber(p); +} + +/*! + \overload + + Arranges all the items in the grid specified by gridX() and gridY(). + + Even if sorting() is enabled, the items are not sorted by this + function. If you want to sort or rearrange the items, use + iconview->sort(iconview->sortDirection()). + + If \a update is true (the default), the viewport is repainted as + well. + + \sa Q3IconView::setGridX(), Q3IconView::setGridY(), Q3IconView::sort() +*/ + +void Q3IconView::arrangeItemsInGrid(bool update) +{ + if (!d->firstItem || !d->lastItem) + return; + + d->containerUpdateLocked = true; + + int w = 0, h = 0, y = d->spacing; + + Q3IconViewItem *item = d->firstItem; + bool changedLayout = false; + while (item) { + bool changed; + Q3IconViewItem *next = makeRowLayout(item, y, changed); + changedLayout = changed || changedLayout; + if(!QApplication::reverseLayout()) + item = next; + w = qMax(w, item->x() + item->width()); + h = qMax(h, item->y() + item->height()); + item = next; + if (d->arrangement == LeftToRight) + h = qMax(h, y); + + if (!item || !item->next) + break; + + item = item->next; + } + + if (d->lastItem && d->arrangement == TopToBottom) { + item = d->lastItem; + int x = item->x(); + while (item && item->x() >= x) { + w = qMax(w, item->x() + item->width()); + h = qMax(h, item->y() + item->height()); + item = item->prev; + } + } + d->containerUpdateLocked = false; + + w = qMax(qMax(d->cachedW, w), d->lastItem->x() + d->lastItem->width()); + h = qMax(qMax(d->cachedH, h), d->lastItem->y() + d->lastItem->height()); + + if (d->arrangement == TopToBottom) + w += d->spacing; + else + h += d->spacing; + + bool ue = updatesEnabled(); + if (ue) + viewport()->setUpdatesEnabled(false); + int vw = visibleWidth(); + int vh = visibleHeight(); + resizeContents(w, h); + bool doAgain = false; + if (d->arrangement == LeftToRight) + doAgain = visibleWidth() != vw; + if (d->arrangement == TopToBottom) + doAgain = visibleHeight() != vh; + if (doAgain) // in the case that the visibleExtend changed because of the resizeContents (scroll bar show/hide), redo layout again + arrangeItemsInGrid(false); + if (ue) + viewport()->setUpdatesEnabled(true); + d->dirty = !isVisible(); + rebuildContainers(); + if (update && (!optimize_layout || changedLayout)) + repaintContents(contentsX(), contentsY(), viewport()->width(), viewport()->height()); +} + +/*! + This variant uses \a grid instead of (gridX(), gridY()). If \a + grid is invalid (see QSize::isValid()), arrangeItemsInGrid() + calculates a valid grid itself and uses that. + + If \a update is true (the default) the viewport is repainted. +*/ + +void Q3IconView::arrangeItemsInGrid(const QSize &grid, bool update) +{ + d->containerUpdateLocked = true; + QSize grid_(grid); + if (!grid_.isValid()) { + int w = 0, h = 0; + Q3IconViewItem *item = d->firstItem; + for (; item; item = item->next) { + w = qMax(w, item->width()); + h = qMax(h, item->height()); + } + + grid_ = QSize(qMax(d->rastX + d->spacing, w), + qMax(d->rastY + d->spacing, h)); + } + + int w = 0, h = 0; + Q3IconViewItem *item = d->firstItem; + for (; item; item = item->next) { + int nx = item->x() / grid_.width(); + int ny = item->y() / grid_.height(); + item->move(nx * grid_.width(), + ny * grid_.height()); + w = qMax(w, item->x() + item->width()); + h = qMax(h, item->y() + item->height()); + item->dirty = false; + } + d->containerUpdateLocked = false; + + resizeContents(w, h); + rebuildContainers(); + if (update) + repaintContents(contentsX(), contentsY(), viewport()->width(), viewport()->height()); +} + +/*! + \reimp +*/ + +void Q3IconView::setContentsPos(int x, int y) +{ + if (d->updateTimer->isActive()) { + d->cachedContentsX = x; + d->cachedContentsY = y; + } else { + d->cachedContentsY = d->cachedContentsX = -1; + Q3ScrollView::setContentsPos(x, y); + } +} + +/*! + \reimp +*/ + +void Q3IconView::showEvent(QShowEvent *) +{ + if (d->dirty) { + resizeContents(qMax(contentsWidth(), viewport()->width()), + qMax(contentsHeight(), viewport()->height())); + if (d->resortItemsWhenInsert) + sort(d->sortDirection); + if (autoArrange()) + arrangeItemsInGrid(false); + } + Q3ScrollView::show(); +} + +/*! + \property Q3IconView::selectionMode + \brief the selection mode of the icon view + + This can be \l Single (the default), \l Extended, \l Multi or \l + NoSelection. +*/ + +void Q3IconView::setSelectionMode(SelectionMode m) +{ + d->selectionMode = m; +} + +Q3IconView::SelectionMode Q3IconView::selectionMode() const +{ + return d->selectionMode; +} + +/*! + Returns a pointer to the item that contains point \a pos, which is + given in contents coordinates, or 0 if no item contains point \a + pos. +*/ + +Q3IconViewItem *Q3IconView::findItem(const QPoint &pos) const +{ + if (!d->firstItem) + return 0; + + Q3IconViewPrivate::ItemContainer *c = d->lastContainer; + for (; c; c = c->p) { + if (c->rect.contains(pos)) + for (int i = c->items.size()-1; i >= 0; --i) + if (c->items.at(i)->contains(pos)) + return c->items.at(i); + } + + return 0; +} + +/*! + \overload + + Returns a pointer to the first item whose text begins with \a + text, or 0 if no such item could be found. Use the \a compare flag + to control the comparison behavior. +*/ + +Q3IconViewItem *Q3IconView::findItem(const QString &text, ComparisonFlags compare) const +{ + if (!d->firstItem) + return 0; + + if (compare == CaseSensitive || compare == 0) + compare |= ExactMatch; + + QString itmtxt; + QString comtxt = text; + if (! (compare & CaseSensitive)) + comtxt = text.toLower(); + + Q3IconViewItem *item; + if (d->currentItem) + item = d->currentItem; + else + item = d->firstItem; + + Q3IconViewItem *beginsWithItem = 0; + Q3IconViewItem *endsWithItem = 0; + Q3IconViewItem *containsItem = 0; + + if (item) { + for (; item; item = item->next) { + if (!(compare & CaseSensitive)) + itmtxt = item->text().toLower(); + else + itmtxt = item->text(); + + if ((compare & ExactMatch)==ExactMatch && itmtxt == comtxt) + return item; + if (compare & BeginsWith && !beginsWithItem && itmtxt.startsWith(comtxt)) + beginsWithItem = containsItem = item; + if (compare & EndsWith && !endsWithItem && itmtxt.endsWith(comtxt)) + endsWithItem = containsItem = item; + if ((compare & ExactMatch)==0 && !containsItem && itmtxt.contains(comtxt)) + containsItem = item; + } + + if (d->currentItem && d->firstItem) { + item = d->firstItem; + for (; item && item != d->currentItem; item = item->next) { + if (!(compare & CaseSensitive)) + itmtxt = item->text().toLower(); + else + itmtxt = item->text(); + + if ((compare & ExactMatch)==ExactMatch && itmtxt == comtxt) + return item; + if (compare & BeginsWith && !beginsWithItem && itmtxt.startsWith(comtxt)) + beginsWithItem = containsItem = item; + if (compare & EndsWith && !endsWithItem && itmtxt.endsWith(comtxt)) + endsWithItem = containsItem = item; + if ((compare & ExactMatch)==0 && !containsItem && itmtxt.contains(comtxt)) + containsItem = item; + } + } + } + + // Obey the priorities + if (beginsWithItem) + return beginsWithItem; + else if (endsWithItem) + return endsWithItem; + else if (containsItem) + return containsItem; + return 0; +} + +/*! + Unselects all the items. +*/ + +void Q3IconView::clearSelection() +{ + selectAll(false); +} + +/*! + In Multi and Extended modes, this function sets all items to be + selected if \a select is true, and to be unselected if \a select + is false. + + In Single and NoSelection modes, this function only changes the + selection status of currentItem(). +*/ + +void Q3IconView::selectAll(bool select) +{ + if (d->selectionMode == NoSelection) + return; + + if (d->selectionMode == Single) { + if (d->currentItem) + d->currentItem->setSelected(select); + return; + } + + bool b = signalsBlocked(); + blockSignals(true); + Q3IconViewItem *item = d->firstItem; + Q3IconViewItem *i = d->currentItem; + bool changed = false; + bool ue = viewport()->updatesEnabled(); + if (ue) + viewport()->setUpdatesEnabled(false); + QRect rr; + for (; item; item = item->next) { + if (select != item->isSelected()) { + item->setSelected(select, true); + rr = rr.united(item->rect()); + changed = true; + } + } + if (ue) + viewport()->setUpdatesEnabled(true); + // we call updateContents not repaintContents because of possible previous updateContents + Q3ScrollView::updateContents(rr); + QApplication::sendPostedEvents(viewport(), QEvent::Paint); + if (i) + setCurrentItem(i); + blockSignals(b); + if (changed) { + emit selectionChanged(); + } +} + +/*! + Inverts the selection. Works only in Multi and Extended selection + mode. +*/ + +void Q3IconView::invertSelection() +{ + if (d->selectionMode == Single || + d->selectionMode == NoSelection) + return; + + bool b = signalsBlocked(); + blockSignals(true); + Q3IconViewItem *item = d->firstItem; + for (; item; item = item->next) + item->setSelected(!item->isSelected(), true); + blockSignals(b); + emit selectionChanged(); +} + +/*! + Repaints the \a item. +*/ + +void Q3IconView::repaintItem(Q3IconViewItem *item) +{ + if (!item || item->dirty) + return; + + if (QRect(contentsX(), contentsY(), visibleWidth(), visibleHeight()). + intersects(QRect(item->x() - 1, item->y() - 1, item->width() + 2, item->height() + 2))) + repaintContents(item->x() - 1, item->y() - 1, item->width() + 2, item->height() + 2); +} + +/*! + Repaints the selected items. +*/ +void Q3IconView::repaintSelectedItems() +{ + if (selectionMode() == NoSelection) + return; + + if (selectionMode() == Single) { + if (!currentItem() || !currentItem()->isSelected()) + return; + QRect itemRect = currentItem()->rect(); //rect in contents coordinates + itemRect.moveBy(-contentsX(), -contentsY()); + viewport()->update(itemRect); + } else { + // check if any selected items are visible + Q3IconViewItem *item = firstItem(); + const QRect vr = QRect(contentsX(), contentsY(), visibleWidth(), visibleHeight()); + + while (item) { + if (item->isSelected() && item->rect().intersects(vr)) + repaintItem(item); + item = item->nextItem(); + } + } +} + +/*! + Makes sure that \a item is entirely visible. If necessary, + ensureItemVisible() scrolls the icon view. + + \sa ensureVisible() +*/ + +void Q3IconView::ensureItemVisible(Q3IconViewItem *item) +{ + if (!item) + return; + + if ((d->updateTimer && d->updateTimer->isActive()) + || (d->fullRedrawTimer && d->fullRedrawTimer->isActive())) + slotUpdate(); + + int w = item->width(); + int h = item->height(); + ensureVisible(item->x() + w / 2, item->y() + h / 2, + w / 2 + 1, h / 2 + 1); +} + +/*! + Finds the first item whose bounding rectangle overlaps \a r and + returns a pointer to that item. \a r is given in content + coordinates. Returns 0 if no item overlaps \a r. + + If you want to find all items that touch \a r, you will need to + use this function and nextItem() in a loop ending at + findLastVisibleItem() and test Q3IconViewItem::rect() for each of + these items. + + \sa findLastVisibleItem() Q3IconViewItem::rect() +*/ + +Q3IconViewItem* Q3IconView::findFirstVisibleItem(const QRect &r) const +{ + Q3IconViewPrivate::ItemContainer *c = d->firstContainer; + Q3IconViewItem *i = 0; + bool alreadyIntersected = false; + for (; c; c = c->n) { + if (c->rect.intersects(r)) { + alreadyIntersected = true; + for (int j = 0; j < c->items.size(); ++j) { + Q3IconViewItem *item = c->items.at(j); + if (r.intersects(item->rect())) { + if (!i) { + i = item; + } else { + QRect r2 = item->rect(); + QRect r3 = i->rect(); + if (r2.y() < r3.y()) + i = item; + else if (r2.y() == r3.y() && + r2.x() < r3.x()) + i = item; + } + } + } + } else { + if (alreadyIntersected) + break; + } + } + + return i; +} + +/*! + Finds the last item whose bounding rectangle overlaps \a r and + returns a pointer to that item. \a r is given in content + coordinates. Returns 0 if no item overlaps \a r. + + \sa findFirstVisibleItem() +*/ + +Q3IconViewItem* Q3IconView::findLastVisibleItem(const QRect &r) const +{ + Q3IconViewPrivate::ItemContainer *c = d->firstContainer; + Q3IconViewItem *i = 0; + bool alreadyIntersected = false; + for (; c; c = c->n) { + if (c->rect.intersects(r)) { + alreadyIntersected = true; + for (int j = 0; j < c->items.size(); ++j) { + Q3IconViewItem *item = c->items.at(j); + if (r.intersects(item->rect())) { + if (!i) { + i = item; + } else { + QRect r2 = item->rect(); + QRect r3 = i->rect(); + if (r2.y() > r3.y()) + i = item; + else if (r2.y() == r3.y() && + r2.x() > r3.x()) + i = item; + } + } + } + } else { + if (alreadyIntersected) + break; + } + } + + return i; +} + +/*! + Clears the icon view. All items are deleted. +*/ + +void Q3IconView::clear() +{ + setContentsPos(0, 0); + d->clearing = true; + bool block = signalsBlocked(); + blockSignals(true); + clearSelection(); + blockSignals(block); + setContentsPos(0, 0); + d->currentItem = 0; + + if (!d->firstItem) { + d->clearing = false; + return; + } + + Q3IconViewItem *item = d->firstItem, *tmp; + d->firstItem = 0; + while (item) { + tmp = item->next; + delete item; + item = tmp; + } + Q3IconViewPrivate::ItemContainer *c = d->firstContainer, *tmpc; + while (c) { + tmpc = c->n; + delete c; + c = tmpc; + } + d->firstContainer = d->lastContainer = 0; + + d->count = 0; + d->lastItem = 0; + setCurrentItem(0); + d->highlightedItem = 0; + d->tmpCurrentItem = 0; + d->drawDragShapes = false; + + resizeContents(0, 0); + // maybe we don't need this update, so delay it + d->fullRedrawTimer->start(0, true); + + d->cleared = true; + d->clearing = false; +} + +/*! + \property Q3IconView::gridX + \brief the horizontal grid of the icon view + + If the value is -1, (the default), Q3IconView computes suitable + column widths based on the icon view's contents. + + Note that setting a grid width overrides setMaxItemWidth(). +*/ + +void Q3IconView::setGridX(int rx) +{ + d->rastX = rx >= 0 ? rx : -1; +} + +/*! + \property Q3IconView::gridY + \brief the vertical grid of the icon view + + If the value is -1, (the default), Q3IconView computes suitable + column heights based on the icon view's contents. +*/ + +void Q3IconView::setGridY(int ry) +{ + d->rastY = ry >= 0 ? ry : -1; +} + +int Q3IconView::gridX() const +{ + return d->rastX; +} + +int Q3IconView::gridY() const +{ + return d->rastY; +} + +/*! + \property Q3IconView::spacing + \brief the space in pixels between icon view items + + The default is 5 pixels. + + Negative values for spacing are illegal. +*/ + +void Q3IconView::setSpacing(int sp) +{ + d->spacing = sp; +} + +int Q3IconView::spacing() const +{ + return d->spacing; +} + +/*! + \property Q3IconView::itemTextPos + \brief the position where the text of each item is drawn. + + Valid values are \l Bottom or \l Right. The default is \l Bottom. +*/ + +void Q3IconView::setItemTextPos(ItemTextPos pos) +{ + if (pos == d->itemTextPos || (pos != Bottom && pos != Right)) + return; + + d->itemTextPos = pos; + + Q3IconViewItem *item = d->firstItem; + for (; item; item = item->next) { + item->wordWrapDirty = true; + item->calcRect(); + } + + arrangeItemsInGrid(true); +} + +Q3IconView::ItemTextPos Q3IconView::itemTextPos() const +{ + return d->itemTextPos; +} + +/*! + \property Q3IconView::itemTextBackground + \brief the brush to use when drawing the background of an item's text. + + By default this brush is set to Qt::NoBrush, meaning that only the + normal icon view background is used. +*/ + +void Q3IconView::setItemTextBackground(const QBrush &brush) +{ + d->itemTextBrush = brush; +} + +QBrush Q3IconView::itemTextBackground() const +{ + return d->itemTextBrush; +} + +/*! + \property Q3IconView::arrangement + \brief the arrangement mode of the icon view + + This can be \l LeftToRight or \l TopToBottom. The default is \l + LeftToRight. +*/ + +void Q3IconView::setArrangement(Arrangement am) +{ + if (d->arrangement == am) + return; + + d->arrangement = am; + + viewport()->setUpdatesEnabled(false); + resizeContents(viewport()->width(), viewport()->height()); + viewport()->setUpdatesEnabled(true); + arrangeItemsInGrid(true); +} + +Q3IconView::Arrangement Q3IconView::arrangement() const +{ + return d->arrangement; +} + +/*! + \property Q3IconView::resizeMode + \brief the resize mode of the icon view + + This can be \l Fixed or \l Adjust. The default is \l Fixed. + See \l ResizeMode. +*/ + +void Q3IconView::setResizeMode(ResizeMode rm) +{ + if (d->resizeMode == rm) + return; + + d->resizeMode = rm; +} + +Q3IconView::ResizeMode Q3IconView::resizeMode() const +{ + return d->resizeMode; +} + +/*! + \property Q3IconView::maxItemWidth + \brief the maximum width that an item may have. + + The default is 100 pixels. + + Note that if the gridX() value is set Q3IconView will ignore + this property. +*/ + +void Q3IconView::setMaxItemWidth(int w) +{ + d->maxItemWidth = w; +} + +/*! + \property Q3IconView::maxItemTextLength + \brief the maximum length (in characters) that an item's text may have. + + The default is 255 characters. +*/ + +void Q3IconView::setMaxItemTextLength(int w) +{ + d->maxItemTextLength = w; +} + +int Q3IconView::maxItemWidth() const +{ + if (d->rastX != -1) + return d->rastX - 2; + else + return d->maxItemWidth; +} + +int Q3IconView::maxItemTextLength() const +{ + return d->maxItemTextLength; +} + +/*! + \property Q3IconView::itemsMovable + \brief whether the user is allowed to move items around in the icon view + + The default is true. +*/ + +void Q3IconView::setItemsMovable(bool b) +{ + d->rearrangeEnabled = b; +} + +bool Q3IconView::itemsMovable() const +{ + return d->rearrangeEnabled; +} + +/*! + \property Q3IconView::autoArrange + \brief whether the icon view rearranges its items when a new item is inserted. + + The default is true. + + Note that if the icon view is not visible at the time of + insertion, Q3IconView defers all position-related work until it is + shown and then calls arrangeItemsInGrid(). +*/ + +void Q3IconView::setAutoArrange(bool b) +{ + d->reorderItemsWhenInsert = b; +} + +bool Q3IconView::autoArrange() const +{ + return d->reorderItemsWhenInsert; +} + +/*! + If \a sort is true, this function sets the icon view to sort items + when a new item is inserted. If \a sort is false, the icon view + will not be sorted. + + Note that autoArrange() must be true for sorting to take place. + + If \a ascending is true (the default), items are sorted in + ascending order. If \a ascending is false, items are sorted in + descending order. + + Q3IconViewItem::compare() is used to compare pairs of items. The + sorting is based on the items' keys; these default to the items' + text unless specifically set to something else. + + \sa Q3IconView::setAutoArrange(), Q3IconView::autoArrange(), + sortDirection(), sort(), Q3IconViewItem::setKey() +*/ + +void Q3IconView::setSorting(bool sort, bool ascending) +{ + d->resortItemsWhenInsert = sort; + d->sortDirection = ascending; +} + +/*! + \property Q3IconView::sorting + \brief whether the icon view sorts on insertion + + The default is false, i.e. no sorting on insertion. + + To set the sorting, use setSorting(). +*/ + +bool Q3IconView::sorting() const +{ + return d->resortItemsWhenInsert; +} + +/*! + \property Q3IconView::sortDirection + \brief whether the sort direction for inserting new items is ascending; + + The default is true (i.e. ascending). This sort direction is only + meaningful if both sorting() and autoArrange() are true. + + To set the sort direction, use setSorting() +*/ + +bool Q3IconView::sortDirection() const +{ + return d->sortDirection; +} + +/*! + \property Q3IconView::wordWrapIconText + \brief whether the item text will be word-wrapped if it is too long + + The default is true. + + If this property is false, icon text that is too long is + truncated, and an ellipsis (...) appended to indicate that + truncation has occurred. The full text can still be seen by the + user if they hover the mouse because the full text is shown in a + tooltip; see setShowToolTips(). +*/ + +void Q3IconView::setWordWrapIconText(bool b) +{ + if (d->wordWrapIconText == (uint)b) + return; + + d->wordWrapIconText = b; + for (Q3IconViewItem *item = d->firstItem; item; item = item->next) { + item->wordWrapDirty = true; + item->calcRect(); + } + arrangeItemsInGrid(true); +} + +bool Q3IconView::wordWrapIconText() const +{ + return d->wordWrapIconText; +} + +/*! + \property Q3IconView::showToolTips + \brief whether the icon view will display a tool tip with the complete text for any truncated item text + + The default is true. Note that this has no effect if + setWordWrapIconText() is true, as it is by default. +*/ + +void Q3IconView::setShowToolTips(bool b) +{ + d->showTips = b; +} + +bool Q3IconView::showToolTips() const +{ + return d->showTips; +} + +/*! + \reimp +*/ +void Q3IconView::contentsMousePressEvent(QMouseEvent *e) +{ + contentsMousePressEventEx(e); +} + +void Q3IconView::contentsMousePressEventEx(QMouseEvent *e) +{ + if (d->rubber) { + d->dragging = false; + delete d->rubber; + d->rubber = 0; + viewport()->update(); + + if (d->scrollTimer) { + disconnect(d->scrollTimer, SIGNAL(timeout()), this, SLOT(doAutoScroll())); + d->scrollTimer->stop(); + delete d->scrollTimer; + d->scrollTimer = 0; + } + } + + d->dragStartPos = e->pos(); + Q3IconViewItem *item = findItem(e->pos()); + d->pressedItem = item; + + if (item) + d->selectAnchor = item; + +#ifndef QT_NO_TEXTEDIT + if (d->renamingItem) + d->renamingItem->renameItem(); +#endif + + if (!d->currentItem && !item && d->firstItem) { + d->currentItem = d->firstItem; + repaintItem(d->firstItem); + } + + if (item && item->dragEnabled()) + d->startDragItem = item; + else + d->startDragItem = 0; + + if (e->button() == Qt::LeftButton && !(e->state() & Qt::ShiftButton) && + !(e->state() & Qt::ControlButton) && item && item->isSelected() && + item->textRect(false).contains(e->pos())) { + + if (!item->renameEnabled()) { + d->mousePressed = true; +#ifndef QT_NO_TEXTEDIT + } else { + ensureItemVisible(item); + setCurrentItem(item); + item->rename(); + goto emit_signals; +#endif + } + } + + d->pressedSelected = item && item->isSelected(); + + if (item && item->isSelectable()) { + if (d->selectionMode == Single) + item->setSelected(true, e->state() & Qt::ControlButton); + else if (d->selectionMode == Multi && !item->isSelected()) + item->setSelected(true, e->state() & Qt::ControlButton); + else if (d->selectionMode == Extended) { + if (e->state() & Qt::ShiftButton) { + d->pressedSelected = false; + bool block = signalsBlocked(); + blockSignals(true); + viewport()->setUpdatesEnabled(false); + QRect r; + bool select = true; + if (d->currentItem) + r = QRect(qMin(d->currentItem->x(), item->x()), + qMin(d->currentItem->y(), item->y()), + 0, 0); + else + r = QRect(0, 0, 0, 0); + if (d->currentItem) { + if (d->currentItem->x() < item->x()) + r.setWidth(item->x() - d->currentItem->x() + item->width()); + else + r.setWidth(d->currentItem->x() - item->x() + d->currentItem->width()); + if (d->currentItem->y() < item->y()) + r.setHeight(item->y() - d->currentItem->y() + item->height()); + else + r.setHeight(d->currentItem->y() - item->y() + d->currentItem->height()); + r = r.normalized(); + Q3IconViewPrivate::ItemContainer *c = d->firstContainer; + bool alreadyIntersected = false; + QRect redraw; + for (; c; c = c->n) { + if (c->rect.intersects(r)) { + alreadyIntersected = true; + for (int i = 0; i < c->items.size(); ++i) { + Q3IconViewItem *item = c->items.at(i); + if (r.intersects(item->rect())) { + redraw = redraw.united(item->rect()); + item->setSelected(select, true); + } + } + } else { + if (alreadyIntersected) + break; + } + } + redraw = redraw.united(item->rect()); + viewport()->setUpdatesEnabled(true); + repaintContents(redraw); + } + blockSignals(block); + viewport()->setUpdatesEnabled(true); + item->setSelected(select, true); + emit selectionChanged(); + } else if (e->state() & Qt::ControlButton) { + d->pressedSelected = false; + item->setSelected(!item->isSelected(), e->state() & Qt::ControlButton); + } else { + item->setSelected(true, e->state() & Qt::ControlButton); + } + } + } else if ((d->selectionMode != Single || e->button() == Qt::RightButton) + && !(e->state() & Qt::ControlButton)) + selectAll(false); + + setCurrentItem(item); + + if (e->button() == Qt::LeftButton) { + if (!item && (d->selectionMode == Multi || + d->selectionMode == Extended)) { + d->tmpCurrentItem = d->currentItem; + d->currentItem = 0; + repaintItem(d->tmpCurrentItem); + if (d->rubber) + delete d->rubber; + d->rubber = 0; + d->rubber = new QRect(e->x(), e->y(), 0, 0); + d->selectedItems.clear(); + if ((e->state() & Qt::ControlButton) == Qt::ControlButton) { + for (Q3IconViewItem *i = firstItem(); i; i = i->nextItem()) + if (i->isSelected()) + d->selectedItems.insert(i, i); + } + } + + d->mousePressed = true; + } + + emit_signals: + if (!d->rubber) { + emit mouseButtonPressed(e->button(), item, e->globalPos()); + emit pressed(item); + emit pressed(item, e->globalPos()); + + if (e->button() == Qt::RightButton) + emit rightButtonPressed(item, e->globalPos()); + } +} + +/*! + \reimp +*/ + +void Q3IconView::contentsContextMenuEvent(QContextMenuEvent *e) +{ + if (!receivers(SIGNAL(contextMenuRequested(Q3IconViewItem*,QPoint)))) { + e->ignore(); + return; + } + if (e->reason() == QContextMenuEvent::Keyboard) { + Q3IconViewItem *item = currentItem(); + QRect r = item ? item->rect() : QRect(0, 0, visibleWidth(), visibleHeight()); + emit contextMenuRequested(item, viewport()->mapToGlobal(contentsToViewport(r.center()))); + } else { + d->mousePressed = false; + Q3IconViewItem *item = findItem(e->pos()); + emit contextMenuRequested(item, e->globalPos()); + } +} + +/*! + \reimp +*/ + +void Q3IconView::contentsMouseReleaseEvent(QMouseEvent *e) +{ + Q3IconViewItem *item = findItem(e->pos()); + d->selectedItems.clear(); + + bool emitClicked = true; + d->mousePressed = false; + d->startDragItem = 0; + + if (d->rubber) { + d->dragging = false; + viewport()->update(); + + if ((d->rubber->topLeft() - d->rubber->bottomRight()).manhattanLength() > + QApplication::startDragDistance()) + emitClicked = false; + delete d->rubber; + d->rubber = 0; + d->currentItem = d->tmpCurrentItem; + d->tmpCurrentItem = 0; + if (d->currentItem) + repaintItem(d->currentItem); + } + + if (d->scrollTimer) { + disconnect(d->scrollTimer, SIGNAL(timeout()), this, SLOT(doAutoScroll())); + d->scrollTimer->stop(); + delete d->scrollTimer; + d->scrollTimer = 0; + } + + if ((d->selectionMode == Extended || d->selectionMode == Multi) && + d->currentItem == d->pressedItem && + d->pressedSelected && d->currentItem) { + if (d->selectionMode == Extended) { + bool block = signalsBlocked(); + blockSignals(true); + clearSelection(); + blockSignals(block); + } + if (d->currentItem->isSelectable()) { + d->currentItem->selected = (d->selectionMode == Extended); + repaintItem(d->currentItem); + } + emit selectionChanged(); + } + d->pressedItem = 0; + + if (emitClicked) { + emit mouseButtonClicked(e->button(), item, e->globalPos()); + emit clicked(item); + emit clicked(item, e->globalPos()); + if (e->button() == Qt::RightButton) + emit rightButtonClicked(item, e->globalPos()); + } +} + +/*! + \reimp +*/ + +void Q3IconView::contentsMouseMoveEvent(QMouseEvent *e) +{ + Q3IconViewItem *item = findItem(e->pos()); + if (d->highlightedItem != item) { + if (item) + emit onItem(item); + else + emit onViewport(); + d->highlightedItem = item; + } + + if (d->mousePressed && e->state() == Qt::NoButton) + d->mousePressed = false; + + if (d->startDragItem) + item = d->startDragItem; + + if (d->mousePressed && d->startDragItem && item && item == d->currentItem && + (item->isSelected() || d->selectionMode == NoSelection) && item->dragEnabled()) { + if ((d->dragStartPos - e->pos()).manhattanLength() > QApplication::startDragDistance()) { + d->mousePressed = false; + d->cleared = false; +#ifndef QT_NO_DRAGANDDROP + startDrag(); +#endif + if (d->tmpCurrentItem) + repaintItem(d->tmpCurrentItem); + } + } else if (d->mousePressed && !d->currentItem && d->rubber) { + doAutoScroll(); + } +} + +/*! + \reimp +*/ + +void Q3IconView::contentsMouseDoubleClickEvent(QMouseEvent *e) +{ + Q3IconViewItem *item = findItem(e->pos()); + if (item) { + selectAll(false); + item->setSelected(true, true); + emit doubleClicked(item); + } +} + +/*! + \reimp +*/ + +#ifndef QT_NO_DRAGANDDROP +void Q3IconView::contentsDragEnterEvent(QDragEnterEvent *e) +{ + d->dragging = true; + d->drawDragShapes = true; + d->tmpCurrentItem = 0; + initDragEnter(e); + d->oldDragPos = e->pos(); + d->oldDragAcceptAction = false; + drawDragShapes(e->pos()); + d->dropped = false; + e->accept(); +} + +/*! + \reimp +*/ + +void Q3IconView::contentsDragMoveEvent(QDragMoveEvent *e) +{ + if (e->pos() == d->oldDragPos) { + if (d->oldDragAcceptAction) + e->acceptAction(); + else + e->ignore(); + return; + } + + drawDragShapes(d->oldDragPos); + d->dragging = false; + + Q3IconViewItem *old = d->tmpCurrentItem; + d->tmpCurrentItem = 0; + + Q3IconViewItem *item = findItem(e->pos()); + + if (item) { + if (old && + old->rect().contains(d->oldDragPos) && + !old->rect().contains(e->pos())) { + old->dragLeft(); + repaintItem(old); + } + if (!item->rect().contains(d->oldDragPos)) + item->dragEntered(); + if (item->acceptDrop(e) || (item->isSelected() && e->source() == viewport())) { + d->oldDragAcceptAction = true; + e->acceptAction(); + } else { + d->oldDragAcceptAction = false; + e->ignore(); + } + + d->tmpCurrentItem = item; + viewport()->update(); + } else { + e->acceptAction(); + d->oldDragAcceptAction = true; + if (old) { + old->dragLeft(); + repaintItem(old); + } + } + + d->oldDragPos = e->pos(); + drawDragShapes(e->pos()); + d->dragging = true; +} + +/*! + \reimp +*/ + +void Q3IconView::contentsDragLeaveEvent(QDragLeaveEvent *) +{ + if (!d->dropped) + drawDragShapes(d->oldDragPos); + d->dragging = false; + + if (d->tmpCurrentItem) { + repaintItem(d->tmpCurrentItem); + d->tmpCurrentItem->dragLeft(); + } + + d->tmpCurrentItem = 0; + d->isIconDrag = false; + d->iconDragData.clear(); +} + +/*! + \reimp +*/ + +void Q3IconView::contentsDropEvent(QDropEvent *e) +{ + d->dropped = true; + d->dragging = false; + drawDragShapes(d->oldDragPos); + + if (d->tmpCurrentItem) + repaintItem(d->tmpCurrentItem); + + Q3IconViewItem *i = findItem(e->pos()); + + if ((!i || i->isSelected()) && e->source() == viewport() && d->currentItem && !d->cleared) { + if (!d->rearrangeEnabled) + return; + QRect r = d->currentItem->rect(); + + d->currentItem->move(e->pos() - d->dragStart); + + int w = d->currentItem->x() + d->currentItem->width() + 1; + int h = d->currentItem->y() + d->currentItem->height() + 1; + + repaintItem(d->currentItem); + repaintContents(r.x(), r.y(), r.width(), r.height()); + + int dx = d->currentItem->x() - r.x(); + int dy = d->currentItem->y() - r.y(); + + Q3IconViewItem *item = d->firstItem; + QRect rr; + for (; item; item = item->next) { + if (item->isSelected() && item != d->currentItem) { + rr = rr.united(item->rect()); + item->moveBy(dx, dy); + rr = rr.united(item->rect()); + } + w = qMax(w, item->x() + item->width() + 1); + h = qMax(h, item->y() + item->height() + 1); + } + repaintContents(rr); + bool fullRepaint = false; + if (w > contentsWidth() || + h > contentsHeight()) + fullRepaint = true; + + int oldw = contentsWidth(); + int oldh = contentsHeight(); + + resizeContents(w, h); + + + if (fullRepaint) { + repaintContents(oldw, 0, contentsWidth() - oldw, contentsHeight()); + repaintContents(0, oldh, contentsWidth(), contentsHeight() - oldh); + } + e->acceptAction(); + } else if (!i && (e->source() != viewport() || d->cleared)) { + QLinkedList<Q3IconDragItem> lst; + if (Q3IconDrag::canDecode(e)) { + QLinkedList<Q3IconDragDataItem> l; + Q3IconDragPrivate::decode(e, l); + QLinkedList<Q3IconDragDataItem>::Iterator it = l.begin(); + for (; it != l.end(); ++it) + lst << (*it).data; + } + emit dropped(e, lst); + } else if (i) { + QLinkedList<Q3IconDragItem> lst; + if (Q3IconDrag::canDecode(e)) { + QLinkedList<Q3IconDragDataItem> l; + Q3IconDragPrivate::decode(e, l); + QLinkedList<Q3IconDragDataItem>::Iterator it = l.begin(); + for (; it != l.end(); ++it) + lst << (*it).data; + } + i->dropped(e, lst); + } + d->isIconDrag = false; +} +#endif + +/*! + \reimp +*/ + +void Q3IconView::resizeEvent(QResizeEvent* e) +{ + Q3ScrollView::resizeEvent(e); + if (d->resizeMode == Adjust) { + optimize_layout = true; + adjustItems(); + optimize_layout = false; +#if 0 // no need for timer delay anymore + d->oldSize = e->oldSize(); + if (d->adjustTimer->isActive()) + d->adjustTimer->stop(); + d->adjustTimer->start(0, true); +#endif + } +} + +/*! + Adjusts the positions of the items to the geometry of the icon + view. +*/ + +void Q3IconView::adjustItems() +{ + d->adjustTimer->stop(); + if (d->resizeMode == Adjust) + arrangeItemsInGrid(true); +} + +/*! + \reimp +*/ + +void Q3IconView::keyPressEvent(QKeyEvent *e) +{ + if (!d->firstItem) + return; + + if (!d->currentItem) { + setCurrentItem(d->firstItem); + if (d->selectionMode == Single) + d->currentItem->setSelected(true, true); + return; + } + + bool selectCurrent = true; + + switch (e->key()) { + case Qt::Key_Escape: + e->ignore(); + break; +#ifndef QT_NO_TEXTEDIT + case Qt::Key_F2: { + if (d->currentItem->renameEnabled()) { + d->currentItem->renameItem(); + d->currentItem->rename(); + return; + } + } break; +#endif + case Qt::Key_Home: { + d->currInputString.clear(); + if (!d->firstItem) + break; + + selectCurrent = false; + + Q3IconViewItem *item = 0; + Q3IconViewPrivate::ItemContainer *c = d->firstContainer; + while (!item && c) { + QList<Q3IconViewItem*> &list = c->items; + for (int j = 0; j < list.size(); ++j) { + Q3IconViewItem *i = list.at(j); + if (!item) { + item = i; + } else { + if (d->arrangement == LeftToRight) { + // we use pixmap so the items textlength are ignored + // find topmost, leftmost item + if (i->pixmapRect(false).y() < item->pixmapRect(false).y() || + (i->pixmapRect(false).y() == item->pixmapRect(false).y() && + i->pixmapRect(false).x() < item->pixmapRect(false).x())) + item = i; + } else { + // find leftmost, topmost item + if (i->pixmapRect(false).x() < item->pixmapRect(false).x() || + (i->pixmapRect(false).x() == item->pixmapRect(false).x() && + i->pixmapRect(false).y() < item->pixmapRect(false).y())) + item = i; + } + } + } + c = c->n; + } + + if (item) { + Q3IconViewItem *old = d->currentItem; + setCurrentItem(item); + ensureItemVisible(item); + handleItemChange(old, e->state() & Qt::ShiftButton, + e->state() & Qt::ControlButton, true); + } + } break; + case Qt::Key_End: { + d->currInputString.clear(); + if (!d->lastItem) + break; + + selectCurrent = false; + + Q3IconViewItem *item = 0; + Q3IconViewPrivate::ItemContainer *c = d->lastContainer; + while (!item && c) { + QList<Q3IconViewItem*> &list = c->items; + for (int j = 0; j < list.size(); ++j) { + Q3IconViewItem *i = list.at(j); + if (!item) { + item = i; + } else { + if (d->arrangement == LeftToRight) { + // find bottommost, rightmost item + if (i->pixmapRect(false).bottom() > item->pixmapRect(false).bottom() || + (i->pixmapRect(false).bottom() == item->pixmapRect(false).bottom() && + i->pixmapRect(false).right() > item->pixmapRect(false).right())) + item = i; + } else { + // find rightmost, bottommost item + if (i->pixmapRect(false).right() > item->pixmapRect(false).right() || + (i->pixmapRect(false).right() == item->pixmapRect(false).right() && + i->pixmapRect(false).bottom() > item->pixmapRect(false).bottom())) + item = i; + } + } + } + c = c->p; + } + + if (item) { + Q3IconViewItem *old = d->currentItem; + setCurrentItem(item); + ensureItemVisible(item); + handleItemChange(old, e->state() & Qt::ShiftButton, + e->state() & Qt::ControlButton, true); + } + } break; + case Qt::Key_Right: { + d->currInputString.clear(); + Q3IconViewItem *item; + selectCurrent = false; + Direction dir = DirRight; + + QRect r(0, d->currentItem->y(), contentsWidth(), d->currentItem->height()); + item = findItem(dir, d->currentItem->rect().center(), r); + + // search the row below from the right + while (!item && r.y() < contentsHeight()) { + r.moveBy(0, d->currentItem->height()); + item = findItem(dir, QPoint(0, r.center().y()), r); + } + + if (item) { + Q3IconViewItem *old = d->currentItem; + setCurrentItem(item); + ensureItemVisible(item); + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } + } break; + case Qt::Key_Left: { + d->currInputString.clear(); + Q3IconViewItem *item; + selectCurrent = false; + Direction dir = DirLeft; + + QRect r(0, d->currentItem->y(), contentsWidth(), d->currentItem->height()); + item = findItem(dir, d->currentItem->rect().center(), r); + + // search the row above from the left + while (!item && r.y() >= 0) { + r.moveBy(0, - d->currentItem->height()); + item = findItem(dir, QPoint(contentsWidth(), r.center().y()), r); + } + + if (item) { + Q3IconViewItem *old = d->currentItem; + setCurrentItem(item); + ensureItemVisible(item); + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } + } break; + case Qt::Key_Space: { + d->currInputString.clear(); + if (d->selectionMode == Single) + break; + + d->currentItem->setSelected(!d->currentItem->isSelected(), true); + } break; + case Qt::Key_Enter: case Qt::Key_Return: + d->currInputString.clear(); + emit returnPressed(d->currentItem); + break; + case Qt::Key_Down: { + d->currInputString.clear(); + Q3IconViewItem *item; + selectCurrent = false; + Direction dir = DirDown; + + QRect r(d->currentItem->x(), 0, d->currentItem->width(), contentsHeight()); + item = findItem(dir, d->currentItem->rect().center(), r); + + // finding the closest item below and to the right + while (!item && r.x() < contentsWidth()) { + r.moveBy(r.width() , 0); + item = findItem(dir, QPoint(r.center().x(), 0), r); + } + + + Q3IconViewItem *i = d->currentItem; + setCurrentItem(item); + item = i; + handleItemChange(item, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } break; + case Qt::Key_Up: { + d->currInputString.clear(); + Q3IconViewItem *item; + selectCurrent = false; + Direction dir = DirUp; + + QRect r(d->currentItem->x(), 0, d->currentItem->width(), contentsHeight()); + item = findItem(dir, d->currentItem->rect().center(), r); + + // finding the closest item above and to the left + while (!item && r.x() >= 0) { + r.moveBy(- r.width(), 0); + item = findItem(dir, QPoint(r.center().x(), contentsHeight()), r); + } + + Q3IconViewItem *i = d->currentItem; + setCurrentItem(item); + item = i; + handleItemChange(item, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } break; + case Qt::Key_Next: { + d->currInputString.clear(); + selectCurrent = false; + QRect r; + if (d->arrangement == LeftToRight) + r = QRect(0, d->currentItem->y() + visibleHeight(), contentsWidth(), visibleHeight()); + else + r = QRect(d->currentItem->x() + visibleWidth(), 0, visibleWidth(), contentsHeight()); + Q3IconViewItem *item = d->currentItem; + Q3IconViewItem *ni = findFirstVisibleItem(r ); + if (!ni) { + if (d->arrangement == LeftToRight) + r = QRect(0, d->currentItem->y() + d->currentItem->height(), contentsWidth(), contentsHeight()); + else + r = QRect(d->currentItem->x() + d->currentItem->width(), 0, contentsWidth(), contentsHeight()); + ni = findLastVisibleItem(r ); + } + if (ni) { + setCurrentItem(ni); + handleItemChange(item, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } + } break; + case Qt::Key_Prior: { + d->currInputString.clear(); + selectCurrent = false; + QRect r; + if (d->arrangement == LeftToRight) + r = QRect(0, d->currentItem->y() - visibleHeight(), contentsWidth(), visibleHeight()); + else + r = QRect(d->currentItem->x() - visibleWidth(), 0, visibleWidth(), contentsHeight()); + Q3IconViewItem *item = d->currentItem; + Q3IconViewItem *ni = findFirstVisibleItem(r ); + if (!ni) { + if (d->arrangement == LeftToRight) + r = QRect(0, 0, contentsWidth(), d->currentItem->y()); + else + r = QRect(0, 0, d->currentItem->x(), contentsHeight()); + ni = findFirstVisibleItem(r ); + } + if (ni) { + setCurrentItem(ni); + handleItemChange(item, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } + } break; + default: + if (!e->text().isEmpty() && e->text()[0].isPrint()) { + selectCurrent = false; + Q3IconViewItem *i = d->currentItem; + if (!i) + i = d->firstItem; + if (!d->inputTimer->isActive()) { + d->currInputString = e->text(); + i = i->next; + if (!i) + i = d->firstItem; + i = findItemByName(i); + } else { + d->inputTimer->stop(); + d->currInputString += e->text(); + i = findItemByName(i); + if (!i) { + d->currInputString = e->text(); + if (d->currentItem && d->currentItem->next) + i = d->currentItem->next; + else + i = d->firstItem; + i = findItemByName(i); + } + } + if (i) { + setCurrentItem(i); + if (d->selectionMode == Extended) { + bool changed = false; + bool block = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(block); + if (!i->selected && i->isSelectable()) { + changed = true; + i->selected = true; + repaintItem(i); + } + if (changed) + emit selectionChanged(); + } + } + d->inputTimer->start(400, true); + } else { + selectCurrent = false; + d->currInputString.clear(); + if (e->state() & Qt::ControlButton) { + switch (e->key()) { + case Qt::Key_A: + selectAll(true); + break; + } + } + e->ignore(); + return; + } + } + + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = d->currentItem; + + if (d->currentItem && !d->currentItem->isSelected() && + d->selectionMode == Single && selectCurrent) { + d->currentItem->setSelected(true); + } + + ensureItemVisible(d->currentItem); +} + +/* + Finds the closest item in the Direction \a dir relative from the point \a relativeTo + which intersects with the searchRect. + + The function chooses the closest item with its center in the \a searchRect. +*/ +Q3IconViewItem* Q3IconView::findItem(Direction dir, + const QPoint &relativeTo, + const QRect &searchRect) const +{ + Q3IconViewItem *centerMatch = 0; + int centerMatchML = 0; + + // gets list of containers with potential items + QList<Q3IconViewPrivate::ItemContainer * >* cList = + d->findContainers(dir, relativeTo, searchRect); + + for (int i = 0; i < cList->size() && !centerMatch; ++i) { + QList<Q3IconViewItem *> &list = (cList->at(i))->items; + for (int j = 0; j < list.size(); ++j) { + Q3IconViewItem *item = list.at(j); + if (neighbourItem(dir, relativeTo, item) && + searchRect.contains(item->rect().center()) && item != currentItem()) { + int ml = (relativeTo - item->rect().center()).manhattanLength(); + if (centerMatch) { + if (ml < centerMatchML) { + centerMatch = item; + centerMatchML = ml; + } + } else { + centerMatch = item; + centerMatchML = ml; + } + } + } + } + return centerMatch; +} + + +/* + Returns true if the items orientation compared to + the point \a relativeTo is correct. +*/ +bool Q3IconView::neighbourItem(Direction dir, + const QPoint &relativeTo, + const Q3IconViewItem *item) const +{ + switch (dir) { + case DirUp: + if (item->rect().center().y() < relativeTo.y()) + return true; + break; + case DirDown: + if (item->rect().center().y() > relativeTo.y()) + return true; + break; + case DirLeft: + if (item->rect().center().x() < relativeTo.x()) + return true; + break; + case DirRight: + if (item->rect().center().x() > relativeTo.x()) + return true; + break; + default: + // nothing + break; + } + return false; +} + +/*! + \reimp +*/ + +void Q3IconView::focusInEvent(QFocusEvent *e) +{ + d->mousePressed = false; + d->inMenuMode = false; + if (d->currentItem) { + repaintItem(d->currentItem); + } else if (d->firstItem && e->reason() != Qt::MouseFocusReason) { + d->currentItem = d->firstItem; + emit currentChanged(d->currentItem); + repaintItem(d->currentItem); + } + + if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) + repaintSelectedItems(); +} + +/*! + \reimp +*/ + +void Q3IconView::focusOutEvent(QFocusEvent *e) +{ + if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) { + d->inMenuMode = + e->reason() == Qt::PopupFocusReason || + (qApp->focusWidget() && qApp->focusWidget()->inherits("QMenuBar")); + if (!d->inMenuMode) + repaintSelectedItems(); + } + if (d->currentItem) + repaintItem(d->currentItem); +} + +/*! + Draws the rubber band using the painter \a p. +*/ + +void Q3IconView::drawRubber(QPainter *p) +{ + if (!p || !d->rubber) + return; + QStyleOptionRubberBand opt; + opt.rect = d->rubber->normalized(); + opt.shape = QRubberBand::Rectangle; + opt.palette = palette(); + opt.state = QStyle::State_None; + style()->drawControl(QStyle::CE_RubberBand, &opt, p, this); +} + +/*! + Returns the Q3DragObject that should be used for drag-and-drop. + This function is called by the icon view when starting a drag to + get the dragobject that should be used for the drag. Subclasses + may reimplement this. + + \sa Q3IconDrag +*/ + +#ifndef QT_NO_DRAGANDDROP +Q3DragObject *Q3IconView::dragObject() +{ + if (!d->currentItem) + return 0; + + QPoint orig = d->dragStartPos; + + Q3IconDrag *drag = new Q3IconDrag(viewport()); + drag->setPixmap((d->currentItem->pixmap() ? + *d->currentItem->pixmap() : QPixmap()), // ### QPicture + QPoint(d->currentItem->pixmapRect().width() / 2, + d->currentItem->pixmapRect().height() / 2)); + + if (d->selectionMode == NoSelection) { + Q3IconViewItem *item = d->currentItem; + drag->append(Q3IconDragItem(), + QRect(item->pixmapRect(false).x() - orig.x(), + item->pixmapRect(false).y() - orig.y(), + item->pixmapRect().width(), item->pixmapRect().height()), + QRect(item->textRect(false).x() - orig.x(), + item->textRect(false).y() - orig.y(), + item->textRect().width(), item->textRect().height())); + } else { + for (Q3IconViewItem *item = d->firstItem; item; item = item->next) { + if (item->isSelected()) { + drag->append(Q3IconDragItem(), + QRect(item->pixmapRect(false).x() - orig.x(), + item->pixmapRect(false).y() - orig.y(), + item->pixmapRect().width(), item->pixmapRect().height()), + QRect(item->textRect(false).x() - orig.x(), + item->textRect(false).y() - orig.y(), + item->textRect().width(), item->textRect().height())); + } + } + } + + return drag; +} + +/*! + Starts a drag. +*/ + +void Q3IconView::startDrag() +{ + if (!d->startDragItem) + return; + + QPoint orig = d->dragStartPos; + d->dragStart = QPoint(orig.x() - d->startDragItem->x(), + orig.y() - d->startDragItem->y()); + d->startDragItem = 0; + d->mousePressed = false; + d->pressedItem = 0; + d->pressedSelected = 0; + + Q3DragObject *drag = dragObject(); + if (!drag) + return; + + if (drag->drag()) + if (drag->target() != viewport()) + emit moved(); +} + +#endif + +/*! + Inserts the Q3IconViewItem \a item in the icon view's grid. \e{You + should never need to call this function.} Instead, insert + Q3IconViewItems by creating them with a pointer to the Q3IconView + that they are to be inserted into. +*/ + +void Q3IconView::insertInGrid(Q3IconViewItem *item) +{ + if (!item) + return; + + if (d->reorderItemsWhenInsert) { + // #### make this efficient - but it's not too dramatic + int y = d->spacing; + + item->dirty = false; + if (item == d->firstItem) { + bool dummy; + makeRowLayout(item, y, dummy); + return; + } + + Q3IconViewItem *begin = rowBegin(item); + y = begin->y(); + while (begin) { + bool dummy; + begin = makeRowLayout(begin, y, dummy); + + if (!begin || !begin->next) + break; + + begin = begin->next; + } + item->dirty = false; + } else { + QRegion r(QRect(0, 0, qMax(contentsWidth(), visibleWidth()), + qMax(contentsHeight(), visibleHeight()))); + + int y = -1; + for (Q3IconViewItem *i = d->firstItem; i; i = i->next) { + r = r.subtracted(i->rect()); + y = qMax(y, i->y() + i->height()); + } + + QVector<QRect> rects = r.rects(); + bool foundPlace = false; + for (int j = 0; j < rects.size(); ++j) { + const QRect rect = rects.at(j); + if (rect.width() >= item->width() && + rect.height() >= item->height()) { + int sx = 0, sy = 0; + if (rect.width() >= item->width() + d->spacing) + sx = d->spacing; + if (rect.height() >= item->height() + d->spacing) + sy = d->spacing; + item->move(rect.x() + sx, rect.y() + sy); + foundPlace = true; + break; + } + } + + if (!foundPlace) + item->move(d->spacing, y + d->spacing); + + resizeContents(qMax(contentsWidth(), item->x() + item->width()), + qMax(contentsHeight(), item->y() + item->height())); + item->dirty = false; + } +} + +/*! + Emits a signal to indicate selection changes. \a i is the + Q3IconViewItem that was selected or de-selected. + + \e{You should never need to call this function.} +*/ + +void Q3IconView::emitSelectionChanged(Q3IconViewItem *i) +{ + emit selectionChanged(); + if (d->selectionMode == Single) + emit selectionChanged(i ? i : d->currentItem); +} + +/*! + \internal +*/ + +void Q3IconView::emitRenamed(Q3IconViewItem *item) +{ + if (!item) + return; + + emit itemRenamed(item, item->text()); + emit itemRenamed(item); +} + +/*! + If a drag enters the icon view the shapes of the objects which the + drag contains are drawn, usnig \a pos as origin. +*/ + +void Q3IconView::drawDragShapes(const QPoint &pos) +{ +#ifndef QT_NO_DRAGANDDROP + if (pos == QPoint(-1, -1)) + return; + + if (!d->drawDragShapes) { + d->drawDragShapes = true; + return; + } + + d->dragPos = pos; + viewport()->update(); +#endif +} + +/*! + When a drag enters the icon view, this function is called to + initialize it. Initializing in this context means getting + information about the drag, for example so that the icon view + knows enough about the drag to be able to draw drag shapes for the + drag data (e.g. shapes of icons which are dragged), etc. +*/ + +#ifndef QT_NO_DRAGANDDROP +void Q3IconView::initDragEnter(QDropEvent *e) +{ + if (Q3IconDrag::canDecode(e)) { + Q3IconDragPrivate::decode(e, d->iconDragData); + d->isIconDrag = true; + } else if (Q3UriDrag::canDecode(e)) { + Q3StrList lst; + Q3UriDrag::decode(e, lst); + d->numDragItems = lst.count(); + } else { + d->numDragItems = 0; + } + +} +#endif + +/*! + This function is called to draw the rectangle \a r of the + background using the painter \a p. + + The default implementation fills \a r with the viewport's + backgroundBrush(). Subclasses can reimplement this to draw custom + backgrounds. + + \sa drawContents() +*/ + +void Q3IconView::drawBackground(QPainter *p, const QRect &r) +{ + p->fillRect(r, viewport()->backgroundBrush()); +} + +/*! + \reimp +*/ + +bool Q3IconView::eventFilter(QObject * o, QEvent * e) +{ + if (o == viewport()) { + switch(e->type()) { + case QEvent::FocusIn: + focusInEvent((QFocusEvent*)e); + return true; + case QEvent::FocusOut: + focusOutEvent((QFocusEvent*)e); + return true; + case QEvent::Enter: + enterEvent(e); + return true; + case QEvent::Paint: + if (o == viewport()) { + viewportPaintEvent((QPaintEvent*)e); + QPainter p(viewport()); + if (d->dragging) { + if (!d->rubber && d->drawDragShapes) { + p.setPen(QPen(Qt::color0)); + QStyleOptionFocusRect opt; + opt.palette = palette(); + opt.state = QStyle::State_KeyboardFocusChange; + opt.backgroundColor = palette().base().color(); + if (d->isIconDrag) { + d->dragPos = contentsToViewport(d->dragPos); + QLinkedList<Q3IconDragDataItem>::Iterator it = d->iconDragData.begin(); + for (; it != d->iconDragData.end(); ++it) { + QRect ir = (*it).item.pixmapRect(); + QRect tr = (*it).item.textRect(); + tr.moveBy(d->dragPos.x(), d->dragPos.y()); + ir.moveBy(d->dragPos.x(), d->dragPos.y()); + if (!ir.intersects(QRect(0, 0, visibleWidth(), visibleHeight()))) + continue; + opt.rect = ir; + style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, &p, this); + opt.rect = tr; + p.drawRect(tr); + style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, &p, this); + } + } else if (d->numDragItems > 0) { + for (int i = 0; i < d->numDragItems; ++i) { + opt.rect.setRect(d->dragPos.x() + i * 40, d->dragPos.y(), 35, 35); + style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, &p, this); + } + + } + p.end(); + } + } else { + p.translate(-contentsX(), -contentsY()); + drawRubber(&p); + } + } + return true; +#ifndef QT_NO_TOOLTIP + case QHelpEvent::ToolTip: + { + if (wordWrapIconText() || !showToolTips()) + return false; + + QHelpEvent *he = static_cast<QHelpEvent *>(e); + Q3IconViewItem *item = findItem(viewportToContents(he->pos())); + if (!item || item->tmpText == item->itemText) { + QToolTip::showText(he->globalPos(), QString(), viewport()); + return true; + } + + QToolTip::showText(he->globalPos(), item->itemText, viewport()); + return true; + } +#endif + default: + // nothing + break; + } + } + + return Q3ScrollView::eventFilter(o, e); +} + + +/*! + \reimp +*/ + +QSize Q3IconView::minimumSizeHint() const +{ + return Q3ScrollView::minimumSizeHint(); +} + +/*! + \internal + Finds the next item after the start item beginning + with \a text. +*/ + +Q3IconViewItem* Q3IconView::findItemByName(Q3IconViewItem *start) +{ + if (!start) + return 0; + QString match = d->currInputString.toLower(); + if (match.length() < 1) + return start; + QString curText; + Q3IconViewItem *i = start; + do { + curText = i->text().toLower(); + if (curText.startsWith(match)) + return i; + i = i->next; + if (!i) + i = d->firstItem; + } while (i != start); + return 0; +} + +/*! + Lays out a row of icons (if Arrangement == \l TopToBottom this is + a column). Starts laying out with the item \a begin. \a y is the + starting coordinate. Returns the last item of the row (column) and + sets the new starting coordinate to \a y. The \a changed parameter + is used internally. + + \warning This function may be made private in a future version of + Qt. We do not recommend calling it. +*/ + +Q3IconViewItem *Q3IconView::makeRowLayout(Q3IconViewItem *begin, int &y, bool &changed) +{ + Q3IconViewItem *end = 0; + + bool reverse = QApplication::reverseLayout(); + changed = false; + + if (d->arrangement == LeftToRight) { + + if (d->rastX == -1) { + // first calculate the row height + int h = 0; + int x = 0; + int ih = 0; + Q3IconViewItem *item = begin; + for (;;) { + x += d->spacing + item->width(); + if (x > visibleWidth() && item != begin) { + item = item->prev; + break; + } + h = qMax(h, item->height()); + ih = qMax(ih, item->pixmapRect().height()); + Q3IconViewItem *old = item; + item = item->next; + if (!item) { + item = old; + break; + } + } + end = item; + + if (d->rastY != -1) + h = qMax(h, d->rastY); + + // now move the items + item = begin; + for (;;) { + item->dirty = false; + int x; + if (item == begin) { + if (reverse) + x = visibleWidth() - d->spacing - item->width(); + else + x = d->spacing; + } else { + if (reverse) + x = item->prev->x() - item->width() - d->spacing; + else + x = item->prev->x() + item->prev->width() + d->spacing; + } + changed = item->move(x, y + ih - item->pixmapRect().height()) || changed; + if (y + h < item->y() + item->height()) + h = qMax(h, ih + item->textRect().height()); + if (item == end) + break; + item = item->next; + } + y += h + d->spacing; + } else { + // first calculate the row height + int h = begin->height(); + int x = d->spacing; + int ih = begin->pixmapRect().height(); + Q3IconViewItem *item = begin; + int i = 0; + int sp = 0; + for (;;) { + int r = calcGridNum(item->width(), d->rastX); + if (item == begin) { + i += r; + sp += r; + x = d->spacing + d->rastX * r; + } else { + sp += r; + i += r; + x = i * d->rastX + sp * d->spacing; + } + if (x > visibleWidth() && item != begin) { + item = item->prev; + break; + } + h = qMax(h, item->height()); + ih = qMax(ih, item->pixmapRect().height()); + Q3IconViewItem *old = item; + item = item->next; + if (!item) { + item = old; + break; + } + } + end = item; + + if (d->rastY != -1) + h = qMax(h, d->rastY); + + // now move the items + item = begin; + i = 0; + sp = 0; + for (;;) { + item->dirty = false; + int r = calcGridNum(item->width(), d->rastX); + if (item == begin) { + if (d->itemTextPos == Bottom) + changed = item->move(d->spacing + (r * d->rastX - item->width()) / 2, + y + ih - item->pixmapRect().height()) || changed; + else + changed = item->move(d->spacing, y + ih - item->pixmapRect().height()) || changed; + i += r; + sp += r; + } else { + sp += r; + int x = i * d->rastX + sp * d->spacing; + if (d->itemTextPos == Bottom) + changed = item->move(x + (r * d->rastX - item->width()) / 2, + y + ih - item->pixmapRect().height()) || changed; + else + changed = item->move(x, y + ih - item->pixmapRect().height()) || changed; + i += r; + } + if (y + h < item->y() + item->height()) + h = qMax(h, ih + item->textRect().height()); + if (item == end) + break; + item = item->next; + } + y += h + d->spacing; + } + + + } else { // -------------------------------- SOUTH ------------------------------ + + int x = y; + + { + int w = 0; + int y = 0; + Q3IconViewItem *item = begin; + for (;;) { + y += d->spacing + item->height(); + if (y > visibleHeight() && item != begin) { + item = item->prev; + break; + } + w = qMax(w, item->width()); + Q3IconViewItem *old = item; + item = item->next; + if (!item) { + item = old; + break; + } + } + end = item; + + if (d->rastX != -1) + w = qMax(w, d->rastX); + + // now move the items + item = begin; + for (;;) { + item->dirty = false; + if (d->itemTextPos == Bottom) { + if (item == begin) + changed = item->move(x + (w - item->width()) / 2, d->spacing) || changed; + else + changed = item->move(x + (w - item->width()) / 2, + item->prev->y() + item->prev->height() + d->spacing) || changed; + } else { + if (item == begin) + changed = item->move(x, d->spacing) || changed; + else + changed = item->move(x, item->prev->y() + item->prev->height() + d->spacing) || changed; + } + if (item == end) + break; + item = item->next; + } + x += w + d->spacing; + } + + y = x; + } + + return end; +} + +/*! + \internal + Calculates how many cells an item of width \a w needs in a grid with of + \a x and returns the result. +*/ + +int Q3IconView::calcGridNum(int w, int x) const +{ + float r = (float)w / (float)x; + if ((w / x) * x != w) + r += 1.0; + return (int)r; +} + +/*! + \internal + Returns the first item of the row which contains \a item. +*/ + +Q3IconViewItem *Q3IconView::rowBegin(Q3IconViewItem *) const +{ + // #### todo + return d->firstItem; +} + +/*! + Sorts and rearranges all the items in the icon view. If \a + ascending is true, the items are sorted in increasing order, + otherwise they are sorted in decreasing order. + + Q3IconViewItem::compare() is used to compare pairs of items. The + sorting is based on the items' keys; these default to the items' + text unless specifically set to something else. + + Note that this function sets the sort order to \a ascending. + + \sa Q3IconViewItem::key(), Q3IconViewItem::setKey(), + Q3IconViewItem::compare(), Q3IconView::setSorting(), + Q3IconView::sortDirection() +*/ + +void Q3IconView::sort(bool ascending) +{ + if (count() == 0) + return; + + d->sortDirection = ascending; + Q3IconViewPrivate::SortableItem *items = new Q3IconViewPrivate::SortableItem[count()]; + + Q3IconViewItem *item = d->firstItem; + int i = 0; + for (; item; item = item->next) + items[i++].item = item; + + qsort(items, count(), sizeof(Q3IconViewPrivate::SortableItem), cmpIconViewItems); + + Q3IconViewItem *prev = 0; + item = 0; + if (ascending) { + for (i = 0; i < (int)count(); ++i) { + item = items[i].item; + if (item) { + item->prev = prev; + if (item->prev) + item->prev->next = item; + item->next = 0; + } + if (i == 0) + d->firstItem = item; + if (i == (int)count() - 1) + d->lastItem = item; + prev = item; + } + } else { + for (i = (int)count() - 1; i >= 0 ; --i) { + item = items[i].item; + if (item) { + item->prev = prev; + if (item->prev) + item->prev->next = item; + item->next = 0; + } + if (i == (int)count() - 1) + d->firstItem = item; + if (i == 0) + d->lastItem = item; + prev = item; + } + } + + delete [] items; + + arrangeItemsInGrid(true); +} + +/*! + \reimp +*/ + +QSize Q3IconView::sizeHint() const +{ + ensurePolished(); + + if (!d->firstItem) + return Q3ScrollView::sizeHint(); + + if (d->dirty && d->firstSizeHint) { + ((Q3IconView*)this)->resizeContents(qMax(400, contentsWidth()), + qMax(400, contentsHeight())); + if (autoArrange()) + ((Q3IconView*)this)->arrangeItemsInGrid(false); + d->firstSizeHint = false; + } + + d->dirty = true; + const QScrollBar *sb = verticalScrollBar(); + QStyleOptionSlider opt; + opt.init(sb); + opt.orientation = sb->orientation(); + int extra = style()->pixelMetric(QStyle::PM_ScrollBarExtent, &opt, sb) + 2 * frameWidth(); + QSize s(qMin(400, contentsWidth() + extra), + qMin(400, contentsHeight() + extra)); + return s; +} + +/*! + \internal +*/ + +void Q3IconView::updateContents() +{ + viewport()->update(); +} + +/*! + \reimp +*/ + +void Q3IconView::enterEvent(QEvent *e) +{ + Q3ScrollView::enterEvent(e); + emit onViewport(); +} + +/*! + \internal + This function is always called when the geometry of an item changes. + This function moves the item into the correct area in the internal + data structure. +*/ + +void Q3IconView::updateItemContainer(Q3IconViewItem *item) +{ + if (!item || d->containerUpdateLocked || (!isVisible() && autoArrange())) + return; + + if (item->d->container1 && d->firstContainer) { + //Special-case to check if we can use removeLast otherwise use removeAll (slower) + if (item->d->container1->items.last() == item) + item->d->container1->items.removeLast(); + else + item->d->container1->items.removeAll(item); + } + item->d->container1 = 0; + if (item->d->container2 && d->firstContainer) { + //Special-case to check if we can use removeLast otherwise use removeAll (slower) + if (item->d->container2->items.last() == item) + item->d->container2->items.removeLast(); + else + item->d->container2->items.removeAll(item); + } + item->d->container2 = 0; + + Q3IconViewPrivate::ItemContainer *c = d->firstContainer; + if (!c) { + appendItemContainer(); + c = d->firstContainer; + } + + const QRect irect = item->rect(); + bool contains = false; + for (;;) { + if (c->rect.intersects(irect)) { + contains = c->rect.contains(irect); + break; + } + + c = c->n; + if (!c) { + appendItemContainer(); + c = d->lastContainer; + } + } + + if (!c) { + qWarning("Q3IconViewItem::updateItemContainer(): No fitting container found!"); + return; + } + + c->items.append(item); + item->d->container1 = c; + + if (!contains) { + c = c->n; + if (!c) { + appendItemContainer(); + c = d->lastContainer; + } + c->items.append(item); + item->d->container2 = c; + } + if (contentsWidth() < irect.right() || contentsHeight() < irect.bottom()) + resizeContents(qMax(contentsWidth(), irect.right()), qMax(contentsHeight(), irect.bottom())); +} + +/*! + \internal + Appends a new rect area to the internal data structure of the items. +*/ + +void Q3IconView::appendItemContainer() +{ + QSize s; + // #### We have to find out which value is best here + if (d->arrangement == LeftToRight) + s = QSize(INT_MAX - 1, RECT_EXTENSION); + else + s = QSize(RECT_EXTENSION, INT_MAX - 1); + + if (!d->firstContainer) { + d->firstContainer = new Q3IconViewPrivate::ItemContainer(0, 0, QRect(QPoint(0, 0), s)); + d->lastContainer = d->firstContainer; + } else { + if (d->arrangement == LeftToRight) + d->lastContainer = new Q3IconViewPrivate::ItemContainer( + d->lastContainer, 0, QRect(d->lastContainer->rect.bottomLeft(), s)); + else + d->lastContainer = new Q3IconViewPrivate::ItemContainer( + d->lastContainer, 0, QRect(d->lastContainer->rect.topRight(), s)); + } +} + +/*! \internal + + Rebuilds the whole internal data structure. This is done when it's + likely that most/all items change their geometry (e.g. in + arrangeItemsInGrid()), because calling this is then more efficient + than calling updateItemContainer() for each item. +*/ + +void Q3IconView::rebuildContainers() +{ + Q3IconViewPrivate::ItemContainer *c = d->firstContainer, *tmpc; + while (c) { + tmpc = c->n; + delete c; + c = tmpc; + } + d->firstContainer = d->lastContainer = 0; + + Q3IconViewItem *item = d->firstItem; + appendItemContainer(); + c = d->lastContainer; + while (item) { + if (c->rect.contains(item->rect())) { + item->d->container1 = c; + item->d->container2 = 0; + c->items.append(item); + item = item->next; + } else if (c->rect.intersects(item->rect())) { + item->d->container1 = c; + c->items.append(item); + c = c->n; + if (!c) { + appendItemContainer(); + c = d->lastContainer; + } + c->items.append(item); + item->d->container2 = c; + item = item->next; + c = c->p; + } else { + if (d->arrangement == LeftToRight) { + if (item->y() < c->rect.y() && c->p) { + c = c->p; + continue; + } + } else { + if (item->x() < c->rect.x() && c->p) { + c = c->p; + continue; + } + } + + c = c->n; + if (!c) { + appendItemContainer(); + c = d->lastContainer; + } + } + } +} + +/*! + \internal +*/ + +void Q3IconView::movedContents(int, int) +{ + if (d->drawDragShapes) { + drawDragShapes(d->oldDragPos); + d->oldDragPos = QPoint(-1, -1); + } +} + +void Q3IconView::handleItemChange(Q3IconViewItem *old, bool shift, + bool control, bool homeend) +{ + if (d->selectionMode == Single) { + bool block = signalsBlocked(); + blockSignals(true); + if (old) + old->setSelected(false); + blockSignals(block); + d->currentItem->setSelected(true, true); + } else if (d->selectionMode == Extended) { + if (shift) { + if (!d->selectAnchor) { + if (old && !old->selected && old->isSelectable()) { + old->selected = true; + repaintItem(old); + } + d->currentItem->setSelected(true, true); + } else { + Q3IconViewItem *from = d->selectAnchor, *to = d->currentItem; + if (!from || !to) + return; + + // checking if it's downwards and if we span rows + bool downwards = false; + bool spanning = false; + if (d->arrangement == LeftToRight) { + if (from->rect().center().y() < to->rect().center().y()) + downwards = true; + } else { + if (from->rect().center().x() < to->rect().center().x()) + downwards = true; + } + + QRect fr = from->rect(); + QRect tr = to->rect(); + if (d->arrangement == LeftToRight) { + fr.moveTopLeft(QPoint(tr.x(), fr.y())); + if (!tr.intersects(fr)) + spanning = true; + } else { + fr.moveTopLeft(QPoint(fr.x(), tr.y())); + if (!tr.intersects(fr)) + spanning = true; + } + + + // finding the rectangles + QRect topRect, bottomRect, midRect; + if (!spanning) { + midRect = from->rect().united(to->rect()); + } else { + if (downwards) { + topRect = from->rect(); + bottomRect = to->rect(); + } else { + topRect = to->rect(); + bottomRect = from->rect(); + } + if (d->arrangement == LeftToRight) { + topRect.setRight(contentsWidth()); + bottomRect.setLeft(0); + midRect.setRect(0, topRect.bottom(), + contentsWidth(), + bottomRect.top() - topRect.bottom()); + } else { + topRect.setBottom(contentsHeight()); + bottomRect.setTop(0); + midRect.setRect(topRect.right(), + 0, + bottomRect.left() - topRect.right(), + contentsHeight()); + } + } + + // finding contained items and selecting them + Q3IconViewItem *item = 0; + bool changed = false; + bool midValid = midRect.isValid(); + bool topValid = topRect.isValid(); + bool bottomValid = bottomRect.isValid(); + QRect selectedRect, unselectedRect; + for (item = d->firstItem; item; item = item->next) { + bool contained = false; + QPoint itemCenter = item->rect().center(); + if (midValid && midRect.contains(itemCenter)) + contained = true; + if (!contained && topValid && topRect.contains(itemCenter)) + contained = true; + if (!contained && bottomValid && bottomRect.contains(itemCenter)) + contained = true; + + if (contained) { + if (!item->selected && item->isSelectable()) { + changed = true; + item->selected = true; + selectedRect = selectedRect.united(item->rect()); + } + } else if (item->selected && !control) { + item->selected = false; + unselectedRect = unselectedRect.united(item->rect()); + changed = true; + } + } + + QRect viewRect(contentsX(), contentsY(), + visibleWidth(), visibleHeight()); + + if (viewRect.intersects(selectedRect)) { + if (homeend) + Q3ScrollView::updateContents(viewRect.intersected(selectedRect)); + else + repaintContents(viewRect.intersected(selectedRect)); + } + if (viewRect.intersects(unselectedRect)) { + if (homeend) + Q3ScrollView::updateContents(viewRect.intersected(unselectedRect)); + else + repaintContents(viewRect.intersected(unselectedRect)); + } + + if (changed) + emit selectionChanged(); + } + } else if (!control) { + blockSignals(true); + selectAll(false); + blockSignals(false); + d->currentItem->setSelected(true, true); + } + } else { + if (shift) + d->currentItem->setSelected(!d->currentItem->isSelected(), true); + } +} + +QBitmap Q3IconView::mask(QPixmap *pix) const +{ + QBitmap m; + if (d->maskCache.find(QString::number(pix->serialNumber()), m)) + return m; + if (pix->hasAlphaChannel()) + m = pix->mask(); + else + m = pix->createHeuristicMask(); + d->maskCache.insert(QString::number(pix->serialNumber()), m); + return m; +} + +/*! + Returns true if an iconview item is being renamed; otherwise + returns false. +*/ + +bool Q3IconView::isRenaming() const +{ +#ifndef QT_NO_TEXTEDIT + return d->renamingItem && d->renamingItem->renameBox; +#else + return false; +#endif +} + +/*! + \enum Q3IconView::StringComparisonMode + + This enum type is used to set the string comparison mode when + searching for an item. We'll refer to the string being searched + as the 'target' string. + + \value CaseSensitive The strings must match case sensitively. + \value ExactMatch The target and search strings must match exactly. + \value BeginsWith The target string begins with the search string. + \value EndsWith The target string ends with the search string. + \value Contains The target string contains the search string. + + If you OR these flags together (excluding \c CaseSensitive), the + search criteria be applied in the following order: \c ExactMatch, + \c BeginsWith, \c EndsWith, \c Contains. + + Matching is case-insensitive unless \c CaseSensitive is set. \c + CaseSensitive can be OR-ed with any combination of the other + flags. + + \sa ComparisonFlags +*/ + +/*! + \typedef Q3IconView::ComparisonFlags + + This typedef is used in Q3IconView's API for values that are OR'd + combinations of \l StringComparisonMode values. + + \sa StringComparisonMode +*/ + +QT_END_NAMESPACE + +#endif // QT_NO_ICONVIEW diff --git a/src/qt3support/itemviews/q3iconview.h b/src/qt3support/itemviews/q3iconview.h new file mode 100644 index 0000000..d35a895 --- /dev/null +++ b/src/qt3support/itemviews/q3iconview.h @@ -0,0 +1,519 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3ICONVIEW_H +#define Q3ICONVIEW_H + +#include <Qt3Support/q3scrollview.h> +#include <QtCore/qstring.h> +#include <QtCore/qrect.h> +#include <QtCore/qpoint.h> +#include <QtCore/qsize.h> +#include <QtGui/qfont.h> // QString->QFont conversion +#include <Qt3Support/q3dragobject.h> +#include <QtGui/qbitmap.h> +#include <QtGui/qpicture.h> +#include <Qt3Support/q3valuelist.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_ICONVIEW + +class Q3IconView; +class QPainter; +class QMimeSource; +class QMouseEvent; +class QDragEnterEvent; +class QDragMoveEvent; +class QDragLeaveEvent; +class QKeyEvent; +class QFocusEvent; +class QShowEvent; +class Q3IconViewItem; +class Q3IconViewItemLineEdit; +class QStringList; +class Q3IconDragPrivate; +class QColorGroup; + +#ifndef QT_NO_DRAGANDDROP + +class Q_COMPAT_EXPORT Q3IconDragItem +{ +public: + Q3IconDragItem(); + virtual ~Q3IconDragItem(); + virtual QByteArray data() const; + virtual void setData(const QByteArray &d); + bool operator== (const Q3IconDragItem&) const; + +private: + QByteArray ba; + +}; + +class Q_COMPAT_EXPORT Q3IconDrag : public Q3DragObject +{ + Q_OBJECT +public: + Q3IconDrag(QWidget * dragSource, const char* name = 0); + virtual ~Q3IconDrag(); + + void append(const Q3IconDragItem &item, const QRect &pr, const QRect &tr); + + virtual const char* format(int i) const; + static bool canDecode(QMimeSource* e); + virtual QByteArray encodedData(const char* mime) const; + +private: + Q_DISABLE_COPY(Q3IconDrag) + + Q3IconDragPrivate *d; + QChar endMark; + + friend class Q3IconView; + friend class Q3IconViewPrivate; +}; + +#endif + +class Q3IconViewToolTip; +class Q3IconViewItemPrivate; + +class Q_COMPAT_EXPORT Q3IconViewItem +{ + friend class Q3IconView; + friend class Q3IconViewToolTip; + friend class Q3IconViewItemLineEdit; + +public: + Q3IconViewItem(Q3IconView *parent); + Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after); + Q3IconViewItem(Q3IconView *parent, const QString &text); + Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after, const QString &text); + Q3IconViewItem(Q3IconView *parent, const QString &text, const QPixmap &icon); + Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after, const QString &text, const QPixmap &icon); +#ifndef QT_NO_PICTURE + Q3IconViewItem(Q3IconView *parent, const QString &text, const QPicture &picture); + Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after, const QString &text, const QPicture &picture); +#endif + virtual ~Q3IconViewItem(); + + virtual void setRenameEnabled(bool allow); + virtual void setDragEnabled(bool allow); + virtual void setDropEnabled(bool allow); + + virtual QString text() const; + virtual QPixmap *pixmap() const; +#ifndef QT_NO_PICTURE + virtual QPicture *picture() const; +#endif + virtual QString key() const; + + bool renameEnabled() const; + bool dragEnabled() const; + bool dropEnabled() const; + + Q3IconView *iconView() const; + Q3IconViewItem *prevItem() const; + Q3IconViewItem *nextItem() const; + + int index() const; + + virtual void setSelected(bool s, bool cb); + virtual void setSelected(bool s); + virtual void setSelectable(bool s); + + bool isSelected() const; + bool isSelectable() const; + + virtual void repaint(); + + virtual bool move(int x, int y); + virtual void moveBy(int dx, int dy); + virtual bool move(const QPoint &pnt); + virtual void moveBy(const QPoint &pnt); + + QRect rect() const; + int x() const; + int y() const; + int width() const; + int height() const; + QSize size() const; + QPoint pos() const; + QRect textRect(bool relative = true) const; + QRect pixmapRect(bool relative = true) const; + bool contains(const QPoint& pnt) const; + bool intersects(const QRect& r) const; + + virtual bool acceptDrop(const QMimeSource *mime) const; + +#ifndef QT_NO_TEXTEDIT + void rename(); +#endif + + virtual int compare(Q3IconViewItem *i) const; + + virtual void setText(const QString &text); + virtual void setPixmap(const QPixmap &icon); +#ifndef QT_NO_PICTURE + virtual void setPicture(const QPicture &icon); +#endif + virtual void setText(const QString &text, bool recalc, bool redraw = true); + virtual void setPixmap(const QPixmap &icon, bool recalc, bool redraw = true); + virtual void setKey(const QString &k); + + virtual int rtti() const; + static int RTTI; + +protected: +#ifndef QT_NO_TEXTEDIT + virtual void removeRenameBox(); +#endif + virtual void calcRect(const QString &text_ = QString()); + virtual void paintItem(QPainter *p, const QColorGroup &cg); + virtual void paintFocus(QPainter *p, const QColorGroup &cg); +#ifndef QT_NO_DRAGANDDROP + virtual void dropped(QDropEvent *e, const Q3ValueList<Q3IconDragItem> &lst); +#endif + virtual void dragEntered(); + virtual void dragLeft(); + void setItemRect(const QRect &r); + void setTextRect(const QRect &r); + void setPixmapRect(const QRect &r); + void calcTmpText(); + QString tempText() const; + +private: + void init(Q3IconViewItem *after = 0 +#ifndef QT_NO_PICTURE + , QPicture *pic = 0 +#endif + ); +#ifndef QT_NO_TEXTEDIT + void renameItem(); + void cancelRenameItem(); +#endif + void checkRect(); + + Q3IconView *view; + QString itemText, itemKey; + QString tmpText; + QPixmap *itemIcon; +#ifndef QT_NO_PICTURE + QPicture *itemPic; +#endif + Q3IconViewItem *prev, *next; + uint allow_rename : 1; + uint allow_drag : 1; + uint allow_drop : 1; + uint selected : 1; + uint selectable : 1; + uint dirty : 1; + uint wordWrapDirty : 1; + QRect itemRect, itemTextRect, itemIconRect; +#ifndef QT_NO_TEXTEDIT + Q3IconViewItemLineEdit *renameBox; +#endif + QRect oldRect; + + Q3IconViewItemPrivate *d; + +}; + +class Q3IconViewPrivate; + +class Q_COMPAT_EXPORT Q3IconView : public Q3ScrollView +{ + friend class Q3IconViewItem; + friend class Q3IconViewPrivate; + friend class Q3IconViewToolTip; + + Q_OBJECT + // #### sorting and sort direction do not work + Q_ENUMS(SelectionMode ItemTextPos Arrangement ResizeMode) + Q_PROPERTY(bool sorting READ sorting) + Q_PROPERTY(bool sortDirection READ sortDirection) + Q_PROPERTY(SelectionMode selectionMode READ selectionMode WRITE setSelectionMode) + Q_PROPERTY(int gridX READ gridX WRITE setGridX) + Q_PROPERTY(int gridY READ gridY WRITE setGridY) + Q_PROPERTY(int spacing READ spacing WRITE setSpacing) + Q_PROPERTY(ItemTextPos itemTextPos READ itemTextPos WRITE setItemTextPos) + Q_PROPERTY(QBrush itemTextBackground READ itemTextBackground WRITE setItemTextBackground) + Q_PROPERTY(Arrangement arrangement READ arrangement WRITE setArrangement) + Q_PROPERTY(ResizeMode resizeMode READ resizeMode WRITE setResizeMode) + Q_PROPERTY(int maxItemWidth READ maxItemWidth WRITE setMaxItemWidth) + Q_PROPERTY(int maxItemTextLength READ maxItemTextLength WRITE setMaxItemTextLength) + Q_PROPERTY(bool autoArrange READ autoArrange WRITE setAutoArrange) + Q_PROPERTY(bool itemsMovable READ itemsMovable WRITE setItemsMovable) + Q_PROPERTY(bool wordWrapIconText READ wordWrapIconText WRITE setWordWrapIconText) + Q_PROPERTY(bool showToolTips READ showToolTips WRITE setShowToolTips) + Q_PROPERTY(uint count READ count) + +public: + enum SelectionMode { + Single = 0, + Multi, + Extended, + NoSelection + }; + enum Arrangement { + LeftToRight = 0, + TopToBottom + }; + enum ResizeMode { + Fixed = 0, + Adjust + }; + enum ItemTextPos { + Bottom = 0, + Right + }; + + Q3IconView(QWidget* parent=0, const char* name=0, Qt::WindowFlags f = 0); + virtual ~Q3IconView(); + + virtual void insertItem(Q3IconViewItem *item, Q3IconViewItem *after = 0L); + virtual void takeItem(Q3IconViewItem *item); + + int index(const Q3IconViewItem *item) const; + + Q3IconViewItem *firstItem() const; + Q3IconViewItem *lastItem() const; + Q3IconViewItem *currentItem() const; + virtual void setCurrentItem(Q3IconViewItem *item); + virtual void setSelected(Q3IconViewItem *item, bool s, bool cb = false); + + uint count() const; + +public: + virtual void showEvent(QShowEvent *); + + virtual void setSelectionMode(SelectionMode m); + SelectionMode selectionMode() const; + + Q3IconViewItem *findItem(const QPoint &pos) const; + + enum StringComparisonMode { + CaseSensitive = 0x00001, // 0 0001 + BeginsWith = 0x00002, // 0 0010 + EndsWith = 0x00004, // 0 0100 + Contains = 0x00008, // 0 1000 + ExactMatch = 0x00010 // 1 0000 + }; + typedef uint ComparisonFlags; + Q3IconViewItem *findItem(const QString &text, ComparisonFlags = BeginsWith | Qt::CaseSensitive) const; + virtual void selectAll(bool select); + virtual void clearSelection(); + virtual void invertSelection(); + + virtual void repaintItem(Q3IconViewItem *item); + void repaintSelectedItems(); + + void ensureItemVisible(Q3IconViewItem *item); + Q3IconViewItem* findFirstVisibleItem(const QRect &r) const; + Q3IconViewItem* findLastVisibleItem(const QRect &r) const; + + virtual void clear(); + + virtual void setGridX(int rx); + virtual void setGridY(int ry); + int gridX() const; + int gridY() const; + virtual void setSpacing(int sp); + int spacing() const; + virtual void setItemTextPos(ItemTextPos pos); + ItemTextPos itemTextPos() const; + virtual void setItemTextBackground(const QBrush &b); + QBrush itemTextBackground() const; + virtual void setArrangement(Arrangement am); + Arrangement arrangement() const; + virtual void setResizeMode(ResizeMode am); + ResizeMode resizeMode() const; + virtual void setMaxItemWidth(int w); + int maxItemWidth() const; + virtual void setMaxItemTextLength(int w); + int maxItemTextLength() const; + virtual void setAutoArrange(bool b); + bool autoArrange() const; + virtual void setShowToolTips(bool b); + bool showToolTips() const; + + void setSorting(bool sort, bool ascending = true); + bool sorting() const; + bool sortDirection() const; + + virtual void setItemsMovable(bool b); + bool itemsMovable() const; + virtual void setWordWrapIconText(bool b); + bool wordWrapIconText() const; + + bool eventFilter(QObject * o, QEvent *); + + QSize minimumSizeHint() const; + QSize sizeHint() const; + + virtual void sort(bool ascending = true); + + bool isRenaming() const; + + QVariant inputMethodQuery(Qt::InputMethodQuery query) const; + +public Q_SLOTS: + virtual void arrangeItemsInGrid(const QSize &grid, bool update = true); + virtual void arrangeItemsInGrid(bool update = true); + virtual void setContentsPos(int x, int y); + virtual void updateContents(); + +Q_SIGNALS: + void selectionChanged(); + void selectionChanged(Q3IconViewItem *item); + void currentChanged(Q3IconViewItem *item); + void clicked(Q3IconViewItem *); + void clicked(Q3IconViewItem *, const QPoint &); + void pressed(Q3IconViewItem *); + void pressed(Q3IconViewItem *, const QPoint &); + + void doubleClicked(Q3IconViewItem *item); + void returnPressed(Q3IconViewItem *item); + void rightButtonClicked(Q3IconViewItem* item, const QPoint& pos); + void rightButtonPressed(Q3IconViewItem* item, const QPoint& pos); + void mouseButtonPressed(int button, Q3IconViewItem* item, const QPoint& pos); + void mouseButtonClicked(int button, Q3IconViewItem* item, const QPoint& pos); + void contextMenuRequested(Q3IconViewItem* item, const QPoint &pos); + +#ifndef QT_NO_DRAGANDDROP + void dropped(QDropEvent *e, const Q3ValueList<Q3IconDragItem> &lst); +#endif + void moved(); + void onItem(Q3IconViewItem *item); + void onViewport(); + void itemRenamed(Q3IconViewItem *item, const QString &); + void itemRenamed(Q3IconViewItem *item); + +protected Q_SLOTS: + virtual void doAutoScroll(); + virtual void adjustItems(); + virtual void slotUpdate(); + +private Q_SLOTS: + void movedContents(int dx, int dy); + +protected: + void drawContents(QPainter *p, int cx, int cy, int cw, int ch); + void contentsMousePressEvent(QMouseEvent *e); + void contentsMouseReleaseEvent(QMouseEvent *e); + void contentsMouseMoveEvent(QMouseEvent *e); + void contentsMouseDoubleClickEvent(QMouseEvent *e); + void contentsContextMenuEvent(QContextMenuEvent *e); + +#ifndef QT_NO_DRAGANDDROP + void contentsDragEnterEvent(QDragEnterEvent *e); + void contentsDragMoveEvent(QDragMoveEvent *e); + void contentsDragLeaveEvent(QDragLeaveEvent *e); + void contentsDropEvent(QDropEvent *e); +#endif + + void resizeEvent(QResizeEvent* e); + void keyPressEvent(QKeyEvent *e); + void focusInEvent(QFocusEvent *e); + void focusOutEvent(QFocusEvent *e); + void enterEvent(QEvent *e); + + virtual void drawRubber(QPainter *p); +#ifndef QT_NO_DRAGANDDROP + virtual Q3DragObject *dragObject(); + virtual void startDrag(); +#endif + virtual void insertInGrid(Q3IconViewItem *item); + virtual void drawBackground(QPainter *p, const QRect &r); + + void emitSelectionChanged(Q3IconViewItem * i = 0); + void emitRenamed(Q3IconViewItem *item); + + Q3IconViewItem *makeRowLayout(Q3IconViewItem *begin, int &y, bool &changed); + + void changeEvent(QEvent *); + +private: + Q_DISABLE_COPY(Q3IconView) + + void contentsMousePressEventEx(QMouseEvent *e); + virtual void drawDragShapes(const QPoint &pnt); +#ifndef QT_NO_DRAGANDDROP + virtual void initDragEnter(QDropEvent *e); +#endif + Q3IconViewItem* findItemByName(Q3IconViewItem *start); + void handleItemChange(Q3IconViewItem *old, bool shift, + bool control, bool homeend = false); + + int calcGridNum(int w, int x) const; + Q3IconViewItem *rowBegin(Q3IconViewItem *item) const; + void updateItemContainer(Q3IconViewItem *item); + void appendItemContainer(); + void rebuildContainers(); + enum Direction { + DirUp = 0, + DirDown, + DirLeft, + DirRight + }; + Q3IconViewItem* findItem(Direction dir, + const QPoint &relativeTo, + const QRect &searchRect) const; + bool neighbourItem(Direction dir, + const QPoint &relativeTo, + const Q3IconViewItem *item) const; + QBitmap mask(QPixmap *pix) const; + + Q3IconViewPrivate *d; +}; + +#endif // QT_NO_ICONVIEW + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QICONVIEW_H diff --git a/src/qt3support/itemviews/q3listbox.cpp b/src/qt3support/itemviews/q3listbox.cpp new file mode 100644 index 0000000..da1b6f9 --- /dev/null +++ b/src/qt3support/itemviews/q3listbox.cpp @@ -0,0 +1,4687 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@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 "q3listbox.h" +#ifndef QT_NO_LISTBOX +#include "qapplication.h" +#include "qevent.h" +#include "qfontmetrics.h" +#include "qpainter.h" +#include "qpixmap.h" +#include "qstringlist.h" +#include "qstyle.h" +#include "qstyleoption.h" +#include "qtimer.h" +#include "qvector.h" +#include "qpointer.h" +#ifndef QT_NO_ACCESSIBILITY +#include "qaccessible.h" +#endif + +#include <stdlib.h> + +QT_BEGIN_NAMESPACE + +class Q3ListBoxPrivate +{ +public: + Q3ListBoxPrivate(Q3ListBox *lb): + head(0), last(0), cache(0), cacheIndex(-1), current(0), + highlighted(0), tmpCurrent(0), columnPos(1), rowPos(1), rowPosCache(0), + columnPosOne(0), rowMode(Q3ListBox::FixedNumber), + columnMode(Q3ListBox::FixedNumber), numRows(1), numColumns(1), + currentRow(0), currentColumn(0), + mousePressRow(-1), mousePressColumn(-1), + mouseMoveRow(-1), mouseMoveColumn(-1), mouseInternalPress(false), + scrollTimer(0), updateTimer(0), visibleTimer(0), + selectionMode(Q3ListBox::Single), + count(0), + listBox(lb), currInputString(QString()), + rowModeWins(false), + ignoreMoves(false), + layoutDirty(true), + mustPaintAll(true), + dragging(false), + dirtyDrag (false), + variableHeight(true /* !!! ### false */), + variableWidth(false), + inMenuMode(false) + {} + int findItemByName(int item, const QString &text); + ~Q3ListBoxPrivate(); + + Q3ListBoxItem * head, *last, *cache; + int cacheIndex; + Q3ListBoxItem * current, *highlighted, *tmpCurrent; + + QVector<int> columnPos; + QVector<int> rowPos; + int rowPosCache; + int columnPosOne; + + Q3ListBox::LayoutMode rowMode; + Q3ListBox::LayoutMode columnMode; + int numRows; + int numColumns; + + int currentRow; + int currentColumn; + int mousePressRow; + int mousePressColumn; + int mouseMoveRow; + int mouseMoveColumn; + bool mouseInternalPress; + + QTimer * scrollTimer; + QTimer * updateTimer; + QTimer * visibleTimer; + QTimer * resizeTimer; + + QPoint scrollPos; + + Q3ListBox::SelectionMode selectionMode; + + int count; + + + Q3ListBox *listBox; + QString currInputString; + QTimer *inputTimer; + + Q3ListBoxItem *pressedItem, *selectAnchor; + + uint select :1; + uint pressedSelected :1; + uint rowModeWins :1; + uint ignoreMoves :1; + uint clearing :1; + uint layoutDirty :1; + uint mustPaintAll :1; + uint dragging :1; + uint dirtyDrag :1; + uint variableHeight :1; + uint variableWidth :1; + uint inMenuMode :1; + + QRect *rubber; + + struct SortableItem { + Q3ListBoxItem *item; + }; +}; + + +Q3ListBoxPrivate::~Q3ListBoxPrivate() +{ + Q_ASSERT(!head); +} + + +/*! + \class Q3ListBoxItem + \brief The Q3ListBoxItem class is the base class of all list box items. + + \compat + + This class is an abstract base class used for all list box items. + If you need to insert customized items into a Q3ListBox you must + inherit this class and reimplement paint(), height() and width(). + + \sa Q3ListBox +*/ + +/*! + Constructs an empty list box item in the list box \a listbox. +*/ + +Q3ListBoxItem::Q3ListBoxItem(Q3ListBox* listbox) +{ + lbox = listbox; + s = false; + dirty = true; + custom_highlight = false; + selectable = true; + p = n = 0; + + if (listbox) + listbox->insertItem(this); +} + +/*! + Constructs an empty list box item in the list box \a listbox and + inserts it after the item \a after or at the beginning if \a after + is 0. +*/ + +Q3ListBoxItem::Q3ListBoxItem(Q3ListBox* listbox, Q3ListBoxItem *after) +{ + lbox = listbox; + s = false; + dirty = true; + custom_highlight = false; + selectable = true; + p = n = 0; + + if (listbox) + listbox->insertItem(this, after); +} + + +/*! + Destroys the list box item. +*/ + +Q3ListBoxItem::~Q3ListBoxItem() +{ + if (lbox) + lbox->takeItem(this); +} + + +/*! + Defines whether the list box item is responsible for drawing + itself in a highlighted state when being selected. + + If \a b is false (the default), the list box will draw some + default highlight indicator before calling paint(). + + \sa isSelected(), paint() +*/ +void Q3ListBoxItem::setCustomHighlighting(bool b) +{ + custom_highlight = b; +} + +/*! + \fn void Q3ListBoxItem::paint(QPainter *p) + + Implement this function to draw your item. The painter, \a p, is + already open for painting. + + \sa height(), width() +*/ + +/*! + \fn int Q3ListBoxItem::width(const Q3ListBox* lb) const + + Reimplement this function to return the width of your item. The \a + lb parameter is the same as listBox() and is provided for + convenience and compatibility. + + The default implementation returns + \l{QApplication::globalStrut()}'s width. + + \sa paint(), height() +*/ +int Q3ListBoxItem::width(const Q3ListBox*) const +{ + return QApplication::globalStrut().width(); +} + +/*! + \fn int Q3ListBoxItem::height(const Q3ListBox* lb) const + + Implement this function to return the height of your item. The \a + lb parameter is the same as listBox() and is provided for + convenience and compatibility. + + The default implementation returns + \l{QApplication::globalStrut()}'s height. + + \sa paint(), width() +*/ +int Q3ListBoxItem::height(const Q3ListBox*) const +{ + return QApplication::globalStrut().height(); +} + + +/*! + Returns the text of the item. This text is also used for sorting. + + \sa setText() +*/ +QString Q3ListBoxItem::text() const +{ + return txt; +} + +/*! + Returns the pixmap associated with the item, or 0 if there isn't + one. + + The default implementation returns 0. +*/ +const QPixmap *Q3ListBoxItem::pixmap() const +{ + return 0; +} + +/*! \fn void Q3ListBoxItem::setSelectable(bool b) + + If \a b is true (the default) then this item can be selected by + the user; otherwise this item cannot be selected by the user. + + \sa isSelectable() +*/ + +/*! \fn bool Q3ListBoxItem::isSelectable() const + + Returns true if this item is selectable (the default); otherwise + returns false. + + \sa setSelectable() +*/ + + +/*! + \fn void Q3ListBoxItem::setText(const QString &text) + + Sets the text of the Q3ListBoxItem to \a text. This \a text is also + used for sorting. The text is not shown unless explicitly drawn in + paint(). + + \sa text() +*/ + + +/*! + \class Q3ListBoxText + \brief The Q3ListBoxText class provides list box items that display text. + + \compat + + The text is drawn in the widget's current font. If you need + several different fonts, you must implement your own subclass of + Q3ListBoxItem. + + \sa Q3ListBox, Q3ListBoxItem +*/ + + +/*! + Constructs a list box item in list box \a listbox showing the text + \a text. +*/ +Q3ListBoxText::Q3ListBoxText(Q3ListBox *listbox, const QString &text) + :Q3ListBoxItem(listbox) +{ + setText(text); +} + +/*! + Constructs a list box item showing the text \a text. +*/ + +Q3ListBoxText::Q3ListBoxText(const QString &text) + :Q3ListBoxItem() +{ + setText(text); +} + +/*! + Constructs a list box item in list box \a listbox showing the text + \a text. The item is inserted after the item \a after, or at the + beginning if \a after is 0. +*/ + +Q3ListBoxText::Q3ListBoxText(Q3ListBox* listbox, const QString &text, Q3ListBoxItem *after) + : Q3ListBoxItem(listbox, after) +{ + setText(text); +} + +/*! + Destroys the item. +*/ + +Q3ListBoxText::~Q3ListBoxText() +{ +} + +/*! + Draws the text using \a painter. +*/ + +void Q3ListBoxText::paint(QPainter *painter) +{ + int itemHeight = height(listBox()); + QFontMetrics fm = painter->fontMetrics(); + int yPos = ((itemHeight - fm.height()) / 2) + fm.ascent(); + painter->drawText(3, yPos, text()); +} + +/*! + Returns the height of a line of text in list box \a lb. + + \sa paint(), width() +*/ + +int Q3ListBoxText::height(const Q3ListBox* lb) const +{ + int h = lb ? lb->fontMetrics().lineSpacing() + 2 : 0; + return qMax(h, QApplication::globalStrut().height()); +} + +/*! + Returns the width of this line in list box \a lb. + + \sa paint(), height() +*/ + +int Q3ListBoxText::width(const Q3ListBox* lb) const +{ + int w = lb ? lb->fontMetrics().width(text()) + 6 : 0; + return qMax(w, QApplication::globalStrut().width()); +} + +/*! + \fn int Q3ListBoxText::rtti() const + + \reimp + + Returns 1. + + Make your derived classes return their own values for rtti(), and + you can distinguish between listbox items. You should use values + greater than 1000 preferably a large random number, to allow for + extensions to this class. +*/ + +int Q3ListBoxText::rtti() const +{ + return RTTI; +} + +/*! + \class Q3ListBoxPixmap + \brief The Q3ListBoxPixmap class provides list box items with a + pixmap and optional text. + + \compat + + Items of this class are drawn with the pixmap on the left with the + optional text to the right of the pixmap. + + \sa Q3ListBox, Q3ListBoxItem +*/ + + +/*! + Constructs a new list box item in list box \a listbox showing the + pixmap \a pixmap. +*/ + +Q3ListBoxPixmap::Q3ListBoxPixmap(Q3ListBox* listbox, const QPixmap &pixmap) + : Q3ListBoxItem(listbox) +{ + pm = pixmap; +} + +/*! + Constructs a new list box item showing the pixmap \a pixmap. +*/ + +Q3ListBoxPixmap::Q3ListBoxPixmap(const QPixmap &pixmap) + : Q3ListBoxItem() +{ + pm = pixmap; +} + +/*! + Constructs a new list box item in list box \a listbox showing the + pixmap \a pixmap. The item gets inserted after the item \a after, + or at the beginning if \a after is 0. +*/ + +Q3ListBoxPixmap::Q3ListBoxPixmap(Q3ListBox* listbox, const QPixmap &pixmap, Q3ListBoxItem *after) + : Q3ListBoxItem(listbox, after) +{ + pm = pixmap; +} + + +/*! + Destroys the item. +*/ + +Q3ListBoxPixmap::~Q3ListBoxPixmap() +{ +} + + +/*! + Constructs a new list box item in list box \a listbox showing the + pixmap \a pix and the text \a text. +*/ +Q3ListBoxPixmap::Q3ListBoxPixmap(Q3ListBox* listbox, const QPixmap &pix, const QString& text) + : Q3ListBoxItem(listbox) +{ + pm = pix; + setText(text); +} + +/*! + Constructs a new list box item showing the pixmap \a pix and the + text to \a text. +*/ +Q3ListBoxPixmap::Q3ListBoxPixmap(const QPixmap & pix, const QString& text) + : Q3ListBoxItem() +{ + pm = pix; + setText(text); +} + +/*! + Constructs a new list box item in list box \a listbox showing the + pixmap \a pix and the string \a text. The item gets inserted after + the item \a after, or at the beginning if \a after is 0. +*/ +Q3ListBoxPixmap::Q3ListBoxPixmap(Q3ListBox* listbox, const QPixmap & pix, const QString& text, + Q3ListBoxItem *after) + : Q3ListBoxItem(listbox, after) +{ + pm = pix; + setText(text); +} + +/*! + \fn const QPixmap *Q3ListBoxPixmap::pixmap() const + + Returns the pixmap associated with the item. +*/ + + +/*! + Draws the pixmap using \a painter. +*/ + +void Q3ListBoxPixmap::paint(QPainter *painter) +{ + int itemHeight = height(listBox()); + int yPos; + + const QPixmap *pm = pixmap(); + if (pm && ! pm->isNull()) { + yPos = (itemHeight - pm->height()) / 2; + painter->drawPixmap(3, yPos, *pm); + } + + if (!text().isEmpty()) { + QFontMetrics fm = painter->fontMetrics(); + yPos = ((itemHeight - fm.height()) / 2) + fm.ascent(); + painter->drawText(pm->width() + 5, yPos, text()); + } +} + +/*! + Returns the height of the pixmap in list box \a lb. + + \sa paint(), width() +*/ + +int Q3ListBoxPixmap::height(const Q3ListBox* lb) const +{ + int h; + if (text().isEmpty()) + h = pm.height(); + else + h = qMax(pm.height(), lb->fontMetrics().lineSpacing() + 2); + return qMax(h, QApplication::globalStrut().height()); +} + +/*! + Returns the width of the pixmap plus some margin in list box \a lb. + + \sa paint(), height() +*/ + +int Q3ListBoxPixmap::width(const Q3ListBox* lb) const +{ + if (text().isEmpty()) + return qMax(pm.width() + 6, QApplication::globalStrut().width()); + return qMax(pm.width() + lb->fontMetrics().width(text()) + 6, + QApplication::globalStrut().width()); +} + +/*! + \fn int Q3ListBoxPixmap::rtti() const + + \reimp + + Returns 2. + + Make your derived classes return their own values for rtti(), and + you can distinguish between listbox items. You should use values + greater than 1000 preferably a large random number, to allow for + extensions to this class. +*/ + +int Q3ListBoxPixmap::rtti() const +{ + return RTTI; +} + +/*! + \class Q3ListBox + \brief The Q3ListBox widget provides a list of selectable, read-only items. + + \compat + + This is typically a single-column list in which either no item or + one item is selected, but it can also be used in many other ways. + + Q3ListBox will add scroll bars as necessary, but it isn't intended + for \e really big lists. If you want more than a few thousand + items, it's probably better to use a different widget mainly + because the scroll bars won't provide very good navigation, but + also because Q3ListBox may become slow with huge lists. (See + Q3ListView and Q3Table for possible alternatives.) + + There are a variety of selection modes described in the + Q3ListBox::SelectionMode documentation. The default is \l Single + selection mode, but you can change it using setSelectionMode(). + (setMultiSelection() is still provided for compatibility with Qt + 1.x. We recommend using setSelectionMode() in all code.) + + Because Q3ListBox offers multiple selection it must display + keyboard focus and selection state separately. Therefore there are + functions both to set the selection state of an item, i.e. + setSelected(), and to set which item displays keyboard focus, i.e. + setCurrentItem(). + + The list box normally arranges its items in a single column and + adds a vertical scroll bar if required. It is possible to have a + different fixed number of columns (setColumnMode()), or as many + columns as will fit in the list box's assigned screen space + (setColumnMode(FitToWidth)), or to have a fixed number of rows + (setRowMode()) or as many rows as will fit in the list box's + assigned screen space (setRowMode(FitToHeight)). In all these + cases Q3ListBox will add scroll bars, as appropriate, in at least + one direction. + + If multiple rows are used, each row can be as high as necessary + (the normal setting), or you can request that all items will have + the same height by calling setVariableHeight(false). The same + applies to a column's width, see setVariableWidth(). + + The Q3ListBox's items are Q3ListBoxItem objects. Q3ListBox provides + methods to insert new items as strings, as pixmaps, and as + Q3ListBoxItem * (insertItem() with various arguments), and to + replace an existing item with a new string, pixmap or Q3ListBoxItem + (changeItem() with various arguments). You can also remove items + singly with removeItem() or clear() the entire list box. Note that + if you create a Q3ListBoxItem yourself and insert it, Q3ListBox + takes ownership of the item. + + You can also create a Q3ListBoxItem, such as Q3ListBoxText or + Q3ListBoxPixmap, with the list box as first parameter. The item + will then append itself. When you delete an item it is + automatically removed from the list box. + + The list of items can be arbitrarily large; Q3ListBox will add + scroll bars if necessary. Q3ListBox can display a single-column + (the common case) or multiple-columns, and offers both single and + multiple selection. Q3ListBox does not support multiple-column + items (but Q3ListView and Q3Table do), or tree hierarchies (but + Q3ListView does). + + The list box items can be accessed both as Q3ListBoxItem objects + (recommended) and using integer indexes (the original Q3ListBox + implementation used an array of strings internally, and the API + still supports this mode of operation). Everything can be done + using the new objects, and most things can be done using indexes. + + Each item in a Q3ListBox contains a Q3ListBoxItem. One of the items + can be the current item. The currentChanged() signal and the + highlighted() signal are emitted when a new item becomes current, + e.g. because the user clicks on it or Q3ListBox::setCurrentItem() + is called. The selected() signal is emitted when the user + double-clicks on an item or presses Enter on the current item. + + If the user does not select anything, no signals are emitted and + currentItem() returns -1. + + A list box has Qt::WheelFocus as a default focusPolicy(), i.e. it + can get keyboard focus by tabbing, clicking and through the use of + the mouse wheel. + + New items can be inserted using insertItem(), insertStrList() or + insertStringList(). + + By default, vertical and horizontal scroll bars are added and + removed as necessary. setHScrollBarMode() and setVScrollBarMode() + can be used to change this policy. + + If you need to insert types other than strings and pixmaps, you + must define new classes which inherit Q3ListBoxItem. + + \warning The list box assumes ownership of all list box items and + will delete them when it does not need them any more. + + \inlineimage qlistbox-m.png Screenshot in Motif style + \inlineimage qlistbox-w.png Screenshot in Windows style + + \sa Q3ListView, QComboBox, QButtonGroup +*/ + +/*! + \enum Q3ListBox::SelectionMode + + This enumerated type is used by Q3ListBox to indicate how it reacts + to selection by the user. + + \value Single When the user selects an item, any already-selected + item becomes unselected and the user cannot unselect the selected + item. This means that the user can never clear the selection, even + though the selection may be cleared by the application programmer + using Q3ListBox::clearSelection(). + + \value Multi When the user selects an item the selection status + of that item is toggled and the other items are left alone. + + \value Extended When the user selects an item the selection is + cleared and the new item selected. However, if the user presses + the Ctrl key when clicking on an item, the clicked item gets + toggled and all other items are left untouched. And if the user + presses the Shift key while clicking on an item, all items between + the current item and the clicked item get selected or unselected, + depending on the state of the clicked item. Also, multiple items + can be selected by dragging the mouse while the left mouse button + is kept pressed. + + \value NoSelection Items cannot be selected. + + In other words, \c Single is a real single-selection list box, \c + Multi is a real multi-selection list box, \c Extended is a list + box in which users can select multiple items but usually want to + select either just one or a range of contiguous items, and \c + NoSelection is for a list box where the user can look but not + touch. +*/ + + +/*! + \enum Q3ListBox::LayoutMode + + This enum type is used to specify how Q3ListBox lays out its rows + and columns. + + \value FixedNumber There is a fixed number of rows (or columns). + + \value FitToWidth There are as many columns as will fit + on-screen. + + \value FitToHeight There are as many rows as will fit on-screen. + + \value Variable There are as many rows as are required by the + column mode. (Or as many columns as required by the row mode.) + + Example: When you call setRowMode(FitToHeight), columnMode() + automatically becomes \c Variable to accommodate the row mode + you've set. +*/ + +/*! + \fn void Q3ListBox::onItem(Q3ListBoxItem *i) + + This signal is emitted when the user moves the mouse cursor onto + an item, similar to the QWidget::enterEvent() function. \a i is + the Q3ListBoxItem that the mouse has moved on. +*/ + +// ### bug here too? enter/leave event may noit considered. move the +// mouse out of the window and back in, to the same item - does it +// work? + +/*! + \fn void Q3ListBox::onViewport() + + This signal is emitted when the user moves the mouse cursor from + an item to an empty part of the list box. +*/ + + +/*! + Constructs a new empty list box called \a name and with parent \a + parent and widget attributes \a f. + + This constructor sets the Qt::WA_StaticContent and the + Qt::WA_NoBackground attributes to boost performance when drawing + Q3ListBoxItems. This may be unsuitable for custom Q3ListBoxItem + classes, in which case Qt::WA_StaticContents and Qt::WA_NoBackground + should be cleared on the viewport() after construction. +*/ + +Q3ListBox::Q3ListBox(QWidget *parent, const char *name, Qt::WindowFlags f) + : Q3ScrollView(parent, name, f | Qt::WStaticContents | Qt::WNoAutoErase) +{ + d = new Q3ListBoxPrivate(this); + d->updateTimer = new QTimer(this, "listbox update timer"); + d->visibleTimer = new QTimer(this, "listbox visible timer"); + d->inputTimer = new QTimer(this, "listbox input timer"); + d->resizeTimer = new QTimer(this, "listbox resize timer"); + d->clearing = false; + d->pressedItem = 0; + d->selectAnchor = 0; + d->select = false; + d->rubber = 0; + + setMouseTracking(true); + viewport()->setMouseTracking(true); + + connect(d->updateTimer, SIGNAL(timeout()), + this, SLOT(refreshSlot())); + connect(d->visibleTimer, SIGNAL(timeout()), + this, SLOT(ensureCurrentVisible())); + connect(d->resizeTimer, SIGNAL(timeout()), + this, SLOT(adjustItems())); + viewport()->setBackgroundRole(QPalette::Base); + viewport()->setFocusProxy(this); + viewport()->setFocusPolicy(Qt::WheelFocus); + setFocusPolicy(Qt::WheelFocus); + setAttribute(Qt::WA_MacShowFocusRect); +} + + +Q3ListBox * Q3ListBox::changedListBox = 0; + +/*! + Destroys the list box. Deletes all list box items. +*/ + +Q3ListBox::~Q3ListBox() +{ + if (changedListBox == this) + changedListBox = 0; + clear(); + delete d; + d = 0; +} + +/*! + \fn void Q3ListBox::pressed(Q3ListBoxItem *item) + + This signal is emitted when the user presses any mouse button. If + \a item is not 0, the cursor is on \a item. If \a item is 0, the + mouse cursor isn't on any item. + + Note that you must not delete any Q3ListBoxItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListBox::pressed(Q3ListBoxItem *item, const QPoint &pnt) + \overload + + This signal is emitted when the user presses any mouse button. If + \a item is not 0, the cursor is on \a item. If \a item is 0, the + mouse cursor isn't on any item. + + \a pnt is the position of the mouse cursor in the global + coordinate system (QMouseEvent::globalPos()). + + Note that you must not delete any Q3ListBoxItem objects in slots + connected to this signal. + + \sa mouseButtonPressed() rightButtonPressed() clicked() +*/ + +/*! + \fn void Q3ListBox::clicked(Q3ListBoxItem *item) + + This signal is emitted when the user clicks any mouse button. If + \a item is not 0, the cursor is on \a item. If \a item is 0, the + mouse cursor isn't on any item. + + Note that you must not delete any Q3ListBoxItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListBox::clicked(Q3ListBoxItem *item, const QPoint &pnt) + \overload + + This signal is emitted when the user clicks any mouse button. If + \a item is not 0, the cursor is on \a item. If \a item is 0, the + mouse cursor isn't on any item. + + \a pnt is the position of the mouse cursor in the global + coordinate system (QMouseEvent::globalPos()). (If the click's + press and release differs by a pixel or two, \a pnt is the + position at release time.) + + Note that you must not delete any Q3ListBoxItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListBox::mouseButtonClicked (int button, Q3ListBoxItem * item, const QPoint & pos) + + This signal is emitted when the user clicks mouse button \a + button. If \a item is not 0, the cursor is on \a item. If \a item + is 0, the mouse cursor isn't on any item. + + \a pos is the position of the mouse cursor in the global + coordinate system (QMouseEvent::globalPos()). (If the click's + press and release differs by a pixel or two, \a pos is the + position at release time.) + + Note that you must not delete any Q3ListBoxItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListBox::mouseButtonPressed (int button, Q3ListBoxItem * item, const QPoint & pos) + + This signal is emitted when the user presses mouse button \a + button. If \a item is not 0, the cursor is on \a item. If \a item + is 0, the mouse cursor isn't on any item. + + \a pos is the position of the mouse cursor in the global + coordinate system (QMouseEvent::globalPos()). + + Note that you must not delete any Q3ListBoxItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListBox::doubleClicked(Q3ListBoxItem *item) + + This signal is emitted whenever an item is double-clicked. It's + emitted on the second button press, not the second button release. + If \a item is not 0, the cursor is on \a item. If \a item is 0, + the mouse cursor isn't on any item. +*/ + + +/*! + \fn void Q3ListBox::returnPressed(Q3ListBoxItem *item) + + This signal is emitted when Enter or Return is pressed. The + \a item passed in the argument is currentItem(). +*/ + +/*! + \fn void Q3ListBox::rightButtonClicked(Q3ListBoxItem *item, const QPoint& point) + + This signal is emitted when the right button is clicked. The \a + item is the item that the button was clicked on (which could be + 0 if no item was clicked on), and the \a point is where the + click took place in global coordinates. +*/ + + +/*! + \fn void Q3ListBox::rightButtonPressed (Q3ListBoxItem *item, const QPoint &point) + + This signal is emitted when the right button is pressed. The \a + item is the item that the button was pressed over (which could be + 0 if no item was pressed over), and the \a point is where the + press took place in global coordinates. +*/ + +/*! + \fn void Q3ListBox::contextMenuRequested(Q3ListBoxItem *item, const QPoint & pos) + + This signal is emitted when the user invokes a context menu with + the right mouse button or with special system keys, with \a item + being the item under the mouse cursor or the current item, + respectively. + + \a pos is the position for the context menu in the global + coordinate system. +*/ + +/*! + \fn void Q3ListBox::selectionChanged() + + This signal is emitted when the selection set of a list box + changes. This signal is emitted in each selection mode. If the + user selects five items by drag-selecting, Q3ListBox tries to emit + just one selectionChanged() signal so the signal can be connected + to computationally expensive slots. + + \sa selected() currentItem() +*/ + +/*! + \fn void Q3ListBox::selectionChanged(Q3ListBoxItem *item) + \overload + + This signal is emitted when the selection in a \l Single selection + list box changes. \a item is the newly selected list box item. + + \sa selected() currentItem() +*/ + +/*! + \fn void Q3ListBox::currentChanged(Q3ListBoxItem *item) + + This signal is emitted when the user makes a new item the current + item. \a item is the new current list box item. + + \sa setCurrentItem() currentItem() +*/ + +/*! + \fn void Q3ListBox::highlighted(int index) + + This signal is emitted when the user makes a new item the current + item. \a index is the index of the new current item. + + \sa currentChanged() selected() currentItem() selectionChanged() +*/ + +/*! + \fn void Q3ListBox::highlighted(Q3ListBoxItem *item) + + \overload + + This signal is emitted when the user makes a new \a item the current + \a item. + + \sa currentChanged() selected() currentItem() selectionChanged() +*/ + +/*! + \fn void Q3ListBox::highlighted(const QString & text) + + \overload + + This signal is emitted when the user makes a new item the current + item and the item is (or has) as string. The argument is the new + current item's \a text. + + \sa currentChanged() selected() currentItem() selectionChanged() +*/ + +/*! + \fn void Q3ListBox::selected(int index) + + This signal is emitted when the user double-clicks on an item or + presses Enter on the current item. \a index is the index of the + selected item. + + \sa currentChanged() highlighted() selectionChanged() +*/ + +/*! + \fn void Q3ListBox::selected(Q3ListBoxItem *item) + + \overload + + This signal is emitted when the user double-clicks on an \a item or + presses Enter on the current \a item. + + \sa currentChanged() highlighted() selectionChanged() +*/ + +/*! + \fn void Q3ListBox::selected(const QString &text) + + \overload + + This signal is emitted when the user double-clicks on an item or + presses Enter on the current item, and the item is (or has) a + string. The argument is the \a text of the selected item. + + \sa currentChanged() highlighted() selectionChanged() +*/ + +/*! + \property Q3ListBox::count + \brief the number of items in the list box +*/ + +uint Q3ListBox::count() const +{ + return d->count; +} + +#if 0 +/*! + Inserts the string list \a list into the list at position \a + index. + + If \a index is negative, \a list is inserted at the end of the + list. If \a index is too large, the operation is ignored. + + \warning This function uses \c{const char *} rather than QString, + so we recommend against using it. It is provided so that legacy + code will continue to work, and so that programs that certainly + will not need to handle code outside a single 8-bit locale can use + it. See insertStringList() which uses real QStrings. + + \warning This function is never significantly faster than a loop + around insertItem(). + + \sa insertItem(), insertStringList() +*/ + +void Q3ListBox::insertStrList(const QStrList *list, int index) +{ + if (!list) { + Q_ASSERT(list != 0); + return; + } + insertStrList(*list, index); +} +#endif + + +/*! + Inserts the string list \a list into the list at position \a + index. + + If \a index is negative, \a list is inserted at the end of the + list. If \a index is too large, the operation is ignored. + + \warning This function is never significantly faster than a loop + around insertItem(). + + \sa insertItem(), insertStrList() +*/ + +void Q3ListBox::insertStringList(const QStringList & list, int index) +{ + if (index < 0) + index = count(); + for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it) + insertItem(new Q3ListBoxText(*it), index++); +} + + +#if 0 +/*! + \overload + + Inserts the string list \a list into the list at position \a + index. + + If \a index is negative, \a list is inserted at the end of the + list. If \a index is too large, the operation is ignored. + + \warning This function uses \c{const char *} rather than QString, + so we recommend against using it. It is provided so that legacy + code will continue to work, and so that programs that certainly + will not need to handle code outside a single 8-bit locale can use + it. See insertStringList() which uses real QStrings. + + \warning This function is never significantly faster than a loop + around insertItem(). + + \sa insertItem(), insertStringList() +*/ +void Q3ListBox::insertStrList(const QStrList & list, int index) +{ + QStrListIterator it(list); + const char* txt; + if (index < 0) + index = count(); + while ((txt=it.current())) { + ++it; + insertItem(new Q3ListBoxText(QString::fromLatin1(txt)), + index++); + } + if (hasFocus() && !d->current) + setCurrentItem(d->head); +} +#endif + + +/*! + Inserts the \a numStrings strings of the array \a strings into the + list at position \a index. + + If \a index is negative, insertStrList() inserts \a strings at the + end of the list. If \a index is too large, the operation is + ignored. + + \warning This function uses \c{const char *} rather than QString, + so we recommend against using it. It is provided so that legacy + code will continue to work, and so that programs that certainly + will not need to handle code outside a single 8-bit locale can use + it. See insertStringList() which uses real QStrings. + + \warning This function is never significantly faster than a loop + around insertItem(). + + \sa insertItem(), insertStringList() +*/ + +void Q3ListBox::insertStrList(const char **strings, int numStrings, int index) +{ + if (!strings) { + Q_ASSERT(strings != 0); + return; + } + if (index < 0) + index = count(); + int i = 0; + while ((numStrings<0 && strings[i]!=0) || i<numStrings) { + insertItem(new Q3ListBoxText(QString::fromLatin1(strings[i])), + index + i); + i++; + } + if (hasFocus() && !d->current) + setCurrentItem(d->head); +} + +/*! + Inserts the item \a lbi into the list at position \a index. + + If \a index is negative or larger than the number of items in the + list box, \a lbi is inserted at the end of the list. + + \sa insertStrList() +*/ + +void Q3ListBox::insertItem(const Q3ListBoxItem *lbi, int index) +{ + if (!lbi) + return; + + if (index < 0) + index = d->count; + + if (index >= d->count) { + insertItem(lbi, d->last); + return; + } + + Q3ListBoxItem * item = (Q3ListBoxItem *)lbi; + d->count++; + d->cache = 0; + + item->lbox = this; + if (!d->head || index == 0) { + item->n = d->head; + item->p = 0; + d->head = item; + item->dirty = true; + if (item->n) + item->n->p = item; + } else { + Q3ListBoxItem * i = d->head; + while (i->n && index > 1) { + i = i->n; + index--; + } + if (i->n) { + item->n = i->n; + item->p = i; + item->n->p = item; + item->p->n = item; + } else { + i->n = item; + item->p = i; + item->n = 0; + } + } + + if (hasFocus() && !d->current) { + d->current = d->head; + updateItem(d->current); + emit highlighted(d->current); + emit highlighted(d->current->text()); + emit highlighted(index); + } + + triggerUpdate(true); +} + +/*! + \overload + + Inserts the item \a lbi into the list after the item \a after, or + at the beginning if \a after is 0. + + \sa insertStrList() +*/ + +void Q3ListBox::insertItem(const Q3ListBoxItem *lbi, const Q3ListBoxItem *after) +{ + if (!lbi) + return; + + Q3ListBoxItem * item = (Q3ListBoxItem*)lbi; + d->count++; + d->cache = 0; + + item->lbox = this; + if (!d->head || !after) { + item->n = d->head; + item->p = 0; + d->head = item; + item->dirty = true; + if (item->n) + item->n->p = item; + } else { + Q3ListBoxItem * i = (Q3ListBoxItem*) after; + if (i) { + item->n = i->n; + item->p = i; + if (item->n) + item->n->p = item; + if (item->p) + item->p->n = item; + } + } + + if (after == d->last) + d->last = (Q3ListBoxItem*) lbi; + + if (hasFocus() && !d->current) { + d->current = d->head; + updateItem(d->current); + emit highlighted(d->current); + emit highlighted(d->current->text()); + emit highlighted(index(d->current)); + } + + triggerUpdate(true); +} + +/*! + \overload + + Inserts a new list box text item with the text \a text into the + list at position \a index. + + If \a index is negative, \a text is inserted at the end of the + list. + + \sa insertStrList() +*/ + +void Q3ListBox::insertItem(const QString &text, int index) +{ + insertItem(new Q3ListBoxText(text), index); +} + +/*! + \overload + + Inserts a new list box pixmap item with the pixmap \a pixmap into + the list at position \a index. + + If \a index is negative, \a pixmap is inserted at the end of the + list. + + \sa insertStrList() +*/ + +void Q3ListBox::insertItem(const QPixmap &pixmap, int index) +{ + insertItem(new Q3ListBoxPixmap(pixmap), index); +} + +/*! + \overload + + Inserts a new list box pixmap item with the pixmap \a pixmap and + the text \a text into the list at position \a index. + + If \a index is negative, \a pixmap is inserted at the end of the + list. + + \sa insertStrList() +*/ + +void Q3ListBox::insertItem(const QPixmap &pixmap, const QString &text, int index) +{ + insertItem(new Q3ListBoxPixmap(pixmap, text), index); +} + +/*! + Removes and deletes the item at position \a index. If \a index is + equal to currentItem(), a new item becomes current and the + currentChanged() and highlighted() signals are emitted. + + \sa insertItem(), clear() +*/ + +void Q3ListBox::removeItem(int index) +{ + bool wasVisible = itemVisible(currentItem()); + delete item(index); + triggerUpdate(true); + if (wasVisible) + ensureCurrentVisible(); +} + + +/*! + Deletes all the items in the list. + + \sa removeItem() +*/ + +void Q3ListBox::clear() +{ + setContentsPos(0, 0); + bool blocked = signalsBlocked(); + blockSignals(true); + d->clearing = true; + d->current = 0; + d->tmpCurrent = 0; + Q3ListBoxItem * i = d->head; + d->head = 0; + while (i) { + Q3ListBoxItem * n = i->n; + i->n = i->p = 0; + delete i; + i = n; + } + d->count = 0; + d->numRows = 1; + d->numColumns = 1; + d->currentRow = 0; + d->currentColumn = 0; + d->mousePressRow = -1; + d->mousePressColumn = -1; + d->mouseMoveRow = -1; + d->mouseMoveColumn = -1; + clearSelection(); + d->selectAnchor = 0; + blockSignals(blocked); + triggerUpdate(true); + d->last = 0; + d->clearing = false; +} + + +/*! + Returns the text at position \a index, or an empty string if there + is no text at that position. + + \sa pixmap() +*/ + +QString Q3ListBox::text(int index) const +{ + Q3ListBoxItem * i = item(index); + if (i) + return i->text(); + return QString(); +} + + +/*! + Returns a pointer to the pixmap at position \a index, or 0 if + there is no pixmap there. + + \sa text() +*/ + +const QPixmap *Q3ListBox::pixmap(int index) const +{ + Q3ListBoxItem * i = item(index); + if (i) + return i->pixmap(); + return 0; +} + +/*! + \overload + + Replaces the item at position \a index with a new list box text + item with text \a text. + + The operation is ignored if \a index is out of range. + + \sa insertItem(), removeItem() +*/ + +void Q3ListBox::changeItem(const QString &text, int index) +{ + if(index >= 0 && index < (int)count()) + changeItem(new Q3ListBoxText(text), index); +} + +/*! + \overload + + Replaces the item at position \a index with a new list box pixmap + item with pixmap \a pixmap. + + The operation is ignored if \a index is out of range. + + \sa insertItem(), removeItem() +*/ + +void Q3ListBox::changeItem(const QPixmap &pixmap, int index) +{ + if(index >= 0 && index < (int)count()) + changeItem(new Q3ListBoxPixmap(pixmap), index); +} + +/*! + \overload + + Replaces the item at position \a index with a new list box pixmap + item with pixmap \a pixmap and text \a text. + + The operation is ignored if \a index is out of range. + + \sa insertItem(), removeItem() +*/ + +void Q3ListBox::changeItem(const QPixmap &pixmap, const QString &text, int index) +{ + if(index >= 0 && index < (int)count()) + changeItem(new Q3ListBoxPixmap(pixmap, text), index); +} + + + +/*! + Replaces the item at position \a index with \a lbi. If \a index is + negative or too large, changeItem() does nothing. + + The item that has been changed will become selected. + + \sa insertItem(), removeItem() +*/ + +void Q3ListBox::changeItem(const Q3ListBoxItem *lbi, int index) +{ + if (!lbi || index < 0 || index >= (int)count()) + return; + + removeItem(index); + insertItem(lbi, index); + setCurrentItem(index); +} + + +/*! + \property Q3ListBox::numItemsVisible + \brief the number of visible items. + + Both partially and entirely visible items are counted. +*/ + +int Q3ListBox::numItemsVisible() const +{ + doLayout(); + + int columns = 0; + + int x = contentsX(); + int i=0; + while (i < (int)d->columnPos.size()-1 && + d->columnPos[i] < x) + i++; + if (i < (int)d->columnPos.size()-1 && + d->columnPos[i] > x) + columns++; + x += visibleWidth(); + while (i < (int)d->columnPos.size()-1 && + d->columnPos[i] < x) { + i++; + columns++; + } + + int y = contentsY(); + int rows = 0; + while (i < (int)d->rowPos.size()-1 && + d->rowPos[i] < y) + i++; + if (i < (int)d->rowPos.size()-1 && + d->rowPos[i] > y) + rows++; + y += visibleHeight(); + while (i < (int)d->rowPos.size()-1 && + d->rowPos[i] < y) { + i++; + rows++; + } + + return rows*columns; +} + +int Q3ListBox::currentItem() const +{ + if (!d->current || !d->head) + return -1; + + return index(d->current); +} + + +/*! + \property Q3ListBox::currentText + \brief the text of the current item. + + This is equivalent to text(currentItem()). +*/ + + +/*! + \property Q3ListBox::currentItem + \brief the current highlighted item + + When setting this property, the highlighting is moved to the item + and the list box scrolled as necessary. + + If no item is current, currentItem() returns -1. +*/ + +void Q3ListBox::setCurrentItem(int index) +{ + setCurrentItem(item(index)); +} + +/*! + \reimp +*/ +QVariant Q3ListBox::inputMethodQuery(Qt::InputMethodQuery query) const +{ + if (query == Qt::ImMicroFocus) + return d->current ? itemRect(d->current) : QRect(); + return QWidget::inputMethodQuery(query); +} + +/*! + \overload + + Sets the current item to the Q3ListBoxItem \a i. +*/ +void Q3ListBox::setCurrentItem(Q3ListBoxItem * i) +{ + if (!i || d->current == i) + return; + + Q3ListBoxItem * o = d->current; + d->current = i; + int ind = index(i); + + if (i && selectionMode() == Single) { + bool changed = false; + if (o && o->s) { + changed = true; + o->s = false; + } + if (i && !i->s && d->selectionMode != NoSelection && i->isSelectable()) { + i->s = true; + changed = true; + emit selectionChanged(i); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), ind+1, QAccessible::StateChanged); +#endif + } + if (changed) { + emit selectionChanged(); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection); +#endif + } + } + + d->currentColumn = ind / numRows(); + d->currentRow = ind % numRows(); + if (o) + updateItem(o); + if (i) + updateItem(i); + // scroll after the items are redrawn + d->visibleTimer->start(1, true); + + QString tmp; + if (i) + tmp = i->text(); + emit highlighted(i); + if (!tmp.isNull()) + emit highlighted(tmp); + emit highlighted(ind); + emit currentChanged(i); + +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), ind+1, QAccessible::Focus); +#endif +} + + +/*! + Returns a pointer to the item at position \a index, or 0 if \a + index is out of bounds. + + \sa index() +*/ + +Q3ListBoxItem *Q3ListBox::item(int index) const +{ + if (index < 0 || index > d->count -1) + return 0; + + Q3ListBoxItem * i = d->head; + + if (d->cache && index > 0) { + i = d->cache; + int idx = d->cacheIndex; + while (i && idx < index) { + idx++; + i = i->n; + } + while (i && idx > index) { + idx--; + i = i->p; + } + } else { + int idx = index; + while (i && idx > 0) { + idx--; + i = i->n; + } + } + + if (index > 0) { + d->cache = i; + d->cacheIndex = index; + } + + return i; +} + + +/*! + Returns the index of \a lbi, or -1 if the item is not in this list + box or \a lbi is 0. + + \sa item() +*/ + +int Q3ListBox::index(const Q3ListBoxItem * lbi) const +{ + if (!lbi) + return -1; + Q3ListBoxItem * i_n = d->head; + int c_n = 0; + if (d->cache) { + i_n = d->cache; + c_n = d->cacheIndex; + } + Q3ListBoxItem* i_p = i_n; + int c_p = c_n; + while ((i_n != 0 || i_p != 0) && i_n != lbi && i_p != lbi) { + if (i_n) { + c_n++; + i_n = i_n->n; + } + if (i_p) { + c_p--; + i_p = i_p->p; + } + } + if (i_p == lbi) + return c_p; + if (i_n == lbi) + return c_n; + return -1; +} + + + +/*! + Returns true if the item at position \a index is at least partly + visible; otherwise returns false. +*/ + +bool Q3ListBox::itemVisible(int index) +{ + Q3ListBoxItem * i = item(index); + return i ? itemVisible(i) : false; +} + + +/*! + \overload + + Returns true if \a item is at least partly visible; otherwise + returns false. +*/ + +bool Q3ListBox::itemVisible(const Q3ListBoxItem * item) +{ + if (d->layoutDirty) + doLayout(); + + int i = index(item); + int col = i / numRows(); + int row = i % numRows(); + return (d->columnPos[col] < contentsX()+visibleWidth() && + d->rowPos[row] < contentsY()+visibleHeight() && + d->columnPos[col+1] > contentsX() && + d->rowPos[row+1] > contentsY()); +} + + +/*! \reimp */ + +void Q3ListBox::mousePressEvent(QMouseEvent *e) +{ + mousePressEventEx(e); +} + +void Q3ListBox::mousePressEventEx(QMouseEvent *e) +{ + d->mouseInternalPress = true; + Q3ListBoxItem * i = itemAt(e->pos()); + + if (!i && !d->current && d->head) { + d->current = d->head; + updateItem(d->head); + } + + if (!i && (d->selectionMode != Single || e->button() == Qt::RightButton) + && !(e->state() & Qt::ControlButton)) + clearSelection(); + + d->select = d->selectionMode == Multi ? (i ? !i->isSelected() : false) : true; + d->pressedSelected = i && i->s; + + if (i) + d->selectAnchor = i; + if (i) { + switch(selectionMode()) { + default: + case Single: + if (!i->s || i != d->current) { + if (i->isSelectable()) + setSelected(i, true); + else + setCurrentItem(i); + } + break; + case Extended: + if (i) { + bool shouldBlock = false; + if (!(e->state() & Qt::ShiftButton) && + !(e->state() & Qt::ControlButton)) { + if (!i->isSelected()) { + bool b = signalsBlocked(); + blockSignals(true); + clearSelection(); + blockSignals(b); + } + setSelected(i, true); + d->dragging = true; // always assume dragging + shouldBlock = true; + } else if (e->state() & Qt::ShiftButton) { + d->pressedSelected = false; + Q3ListBoxItem *oldCurrent = item(currentItem()); + bool down = index(oldCurrent) < index(i); + + Q3ListBoxItem *lit = down ? oldCurrent : i; + bool select = d->select; + bool blocked = signalsBlocked(); + blockSignals(true); + for (;; lit = lit->n) { + if (!lit) { + triggerUpdate(false); + break; + } + if (down && lit == i) { + setSelected(i, select); + triggerUpdate(false); + break; + } + if (!down && lit == oldCurrent) { + setSelected(oldCurrent, select); + triggerUpdate(false); + break; + } + setSelected(lit, select); + } + blockSignals(blocked); + emit selectionChanged(); + } else if (e->state() & Qt::ControlButton) { + setSelected(i, !i->isSelected()); + shouldBlock = true; + d->pressedSelected = false; + } + bool blocked = signalsBlocked(); + blockSignals(shouldBlock); + setCurrentItem(i); + blockSignals(blocked); + } + break; + case Multi: + { + setSelected(i, !i->s); + bool b = signalsBlocked(); + blockSignals(true); + setCurrentItem(i); + blockSignals(b); + break; + } + case NoSelection: + setCurrentItem(i); + break; + } + } else { + bool unselect = true; + if (e->button() == Qt::LeftButton) { + if (d->selectionMode == Multi || + d->selectionMode == Extended) { + d->tmpCurrent = d->current; + d->current = 0; + updateItem(d->tmpCurrent); + if (d->rubber) + delete d->rubber; + d->rubber = 0; + d->rubber = new QRect(e->x(), e->y(), 0, 0); + + if (d->selectionMode == Extended && !(e->state() & Qt::ControlButton)) + selectAll(false); + unselect = false; + } + if (unselect && (e->button() == Qt::RightButton || + (selectionMode() == Multi || selectionMode() == Extended))) + clearSelection(); + } + } + + // for sanity, in case people are event-filtering or whatnot + delete d->scrollTimer; + d->scrollTimer = 0; + if (i) { + d->mousePressColumn = d->currentColumn; + d->mousePressRow = d->currentRow; + } else { + d->mousePressColumn = -1; + d->mousePressRow = -1; + } + d->ignoreMoves = false; + + d->pressedItem = i; + + emit pressed(i); + emit pressed(i, e->globalPos()); + emit mouseButtonPressed(e->button(), i, e->globalPos()); + if (e->button() == Qt::RightButton) + emit rightButtonPressed(i, e->globalPos()); +} + + +/*! \reimp */ + +void Q3ListBox::mouseReleaseEvent(QMouseEvent *e) +{ + if (d->selectionMode == Extended && + d->dragging) { + d->dragging = false; + if (d->current != d->pressedItem) { + updateSelection(); // when we drag, we get an update after we release + } + } + + if (d->rubber) { + drawRubber(); + delete d->rubber; + d->rubber = 0; + d->current = d->tmpCurrent; + updateItem(d->current); + } + if (d->scrollTimer) + mouseMoveEvent(e); + delete d->scrollTimer; + d->scrollTimer = 0; + d->ignoreMoves = false; + + if (d->selectionMode == Extended && + d->current == d->pressedItem && + d->pressedSelected && d->current) { + bool block = signalsBlocked(); + blockSignals(true); + clearSelection(); + blockSignals(block); + d->current->s = true; + emit selectionChanged(); + } + + Q3ListBoxItem * i = itemAt(e->pos()); + bool emitClicked = (d->mousePressColumn != -1 && d->mousePressRow != -1) || !d->pressedItem; + emitClicked = emitClicked && d->pressedItem == i; + d->pressedItem = 0; + d->mousePressRow = -1; + d->mousePressColumn = -1; + d->mouseInternalPress = false; + if (emitClicked) { + emit clicked(i); + emit clicked(i, e->globalPos()); + emit mouseButtonClicked(e->button(), i, e->globalPos()); + if (e->button() == Qt::RightButton) + emit rightButtonClicked(i, e->globalPos()); + } +} + + +/*! \reimp */ + +void Q3ListBox::mouseDoubleClickEvent(QMouseEvent *e) +{ + bool ok = true; + Q3ListBoxItem *i = itemAt(e->pos()); + if (!i || selectionMode() == NoSelection) + ok = false; + + d->ignoreMoves = true; + + if (d->current && ok) { + Q3ListBoxItem * i = d->current; + QString tmp = d->current->text(); + emit selected(currentItem()); + emit selected(i); + if (!tmp.isNull()) + emit selected(tmp); + emit doubleClicked(i); + } +} + + +/*! \reimp */ + +void Q3ListBox::mouseMoveEvent(QMouseEvent *e) +{ + Q3ListBoxItem * i = itemAt(e->pos()); + if (i != d->highlighted) { + if (i) { + emit onItem(i); + } else { + emit onViewport(); + } + d->highlighted = i; + } + + if (d->rubber) { + QRect r = d->rubber->normalized(); + drawRubber(); + d->rubber->setCoords(d->rubber->x(), d->rubber->y(), e->x(), e->y()); + doRubberSelection(r, d->rubber->normalized()); + drawRubber(); + return; + } + + if (((e->state() & (Qt::RightButton | Qt::LeftButton | Qt::MidButton)) == 0) || + d->ignoreMoves) + return; + + // hack to keep the combo (and what else?) working: if we get a + // move outside the listbox without having seen a press, discard + // it. + if (!QRect(0, 0, visibleWidth(), visibleHeight()).contains(e->pos()) && + ((d->mousePressColumn < 0 && d->mousePressRow < 0) + || (e->state() == Qt::NoButton && !d->pressedItem))) + return; + + // figure out in what direction to drag-select and perhaps scroll + int dx = 0; + int x = e->x(); + if (x >= visibleWidth()) { + x = visibleWidth()-1; + dx = 1; + } else if (x < 0) { + x = 0; + dx = -1; + } + d->mouseMoveColumn = columnAt(x + contentsX()); + + // sanitize mousePressColumn, if we got here without a mouse press event + if (d->mousePressColumn < 0 && d->mouseMoveColumn >= 0) + d->mousePressColumn = d->mouseMoveColumn; + if (d->mousePressColumn < 0 && d->currentColumn >= 0) + d->mousePressColumn = d->currentColumn; + + // if it's beyond the last column, use the last one + if (d->mouseMoveColumn < 0) + d->mouseMoveColumn = dx >= 0 ? numColumns()-1 : 0; + + // repeat for y + int dy = 0; + int y = e->y(); + if (y >= visibleHeight()) { + y = visibleHeight()-1; + dy = 1; + } else if (y < 0) { + y = 0; + dy = -1; + } + d->mouseMoveRow = rowAt(y + contentsY()); + + if (d->mousePressRow < 0 && d->mouseMoveRow >= 0) + d->mousePressRow = d->mouseMoveRow; + if (d->mousePressRow < 0 && d->currentRow >= 0) + d->mousePressRow = d->currentRow; + + if (d->mousePressRow < 0) + d->mousePressRow = rowAt(x + contentsX()); + + d->scrollPos = QPoint(dx, dy); + + if ((dx || dy) && !d->scrollTimer && e->state() == Qt::LeftButton && e->button() != Qt::LeftButton) { + // start autoscrolling if necessary + d->scrollTimer = new QTimer(this); + connect(d->scrollTimer, SIGNAL(timeout()), + this, SLOT(doAutoScroll())); + d->scrollTimer->start(100, false); + doAutoScroll(); + } else if (!d->scrollTimer) { + // or just select the required bits + updateSelection(); + } +} + + + +void Q3ListBox::updateSelection() +{ + if (d->mouseMoveColumn >= 0 && d->mouseMoveRow >= 0 && + d->mousePressColumn >= 0 && d->mousePressRow >= 0) { + Q3ListBoxItem * i = item(d->mouseMoveColumn * numRows() + + d->mouseMoveRow); +#ifndef QT_NO_ACCESSIBILITY + int ind = index(i); +#endif + if (selectionMode() == Single || selectionMode() == NoSelection) { + if (i && (d->mouseInternalPress || (windowType() == Qt::Popup))) + setCurrentItem(i); + } else { + if (d->selectionMode == Extended && ( + (d->current == d->pressedItem && d->pressedSelected) || + (d->dirtyDrag && !d->dragging))) { + if (d->dirtyDrag && !d->dragging) // emit after dragging stops + d->dirtyDrag = false; + else + clearSelection(); // don't reset drag-selected items + d->pressedItem = 0; + if (i && i->isSelectable()) { + bool block = signalsBlocked(); + blockSignals(true); + i->s = true; + blockSignals(block); + emit selectionChanged(); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), ind+1, QAccessible::StateChanged); + QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection); + QAccessible::updateAccessibility(viewport(), ind+1, QAccessible::SelectionAdd); +#endif + } + triggerUpdate(false); + } else { + int c = qMin(d->mouseMoveColumn, d->mousePressColumn); + int r = qMin(d->mouseMoveRow, d->mousePressRow); + int c2 = qMax(d->mouseMoveColumn, d->mousePressColumn); + int r2 = qMax(d->mouseMoveRow, d->mousePressRow); + bool changed = false; + while(c <= c2) { + Q3ListBoxItem * i = item(c*numRows()+r); + int rtmp = r; + while(i && rtmp <= r2) { + if ((bool)i->s != (bool)d->select && i->isSelectable()) { + i->s = d->select; +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), ind+1, QAccessible::StateChanged); + QAccessible::updateAccessibility(viewport(), ind+1, d->select ? QAccessible::SelectionAdd : QAccessible::SelectionRemove); +#endif + i->dirty = true; + d->dirtyDrag = changed = true; + } + i = i->n; + rtmp++; + } + c++; + } + if (changed) { + if (!d->dragging) // emit after dragging stops instead + emit selectionChanged(); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection); +#endif + triggerUpdate(false); + } + } + if (i) + setCurrentItem(i); + } + } +} + +void Q3ListBox::repaintSelection() +{ + if (d->numColumns == 1) { + for (uint i = topItem(); itemVisible(i) && i < count(); ++i) { + Q3ListBoxItem *it = item(i); + if (!it) + break; + if (it->isSelected()) + updateItem(it); + } + } else { + for (uint i = 0; i < count(); ++i) { + Q3ListBoxItem *it = item(i); + if (!it) + break; + if (it->isSelected()) + updateItem(it); + } + } +} + +/*! \reimp +*/ + +void Q3ListBox::contentsContextMenuEvent(QContextMenuEvent *e) +{ + if (!receivers(SIGNAL(contextMenuRequested(Q3ListBoxItem*,QPoint)))) { + e->ignore(); + return; + } + if (e->reason() == QContextMenuEvent::Keyboard) { + Q3ListBoxItem *i = item(currentItem()); + if (i) { + QRect r = itemRect(i); + emit contextMenuRequested(i, mapToGlobal(r.topLeft() + QPoint(width() / 2, r.height() / 2))); + } + } else { + Q3ListBoxItem * i = itemAt(contentsToViewport(e->pos())); + emit contextMenuRequested(i, e->globalPos()); + } +} + +/*!\reimp +*/ +void Q3ListBox::keyPressEvent(QKeyEvent *e) +{ + if ((e->key() == Qt::Key_Tab || e->key() == Qt::Key_Backtab) + && e->state() & Qt::ControlButton) + e->ignore(); + + if (count() == 0) { + e->ignore(); + return; + } + + QPointer<Q3ListBox> selfCheck = this; + + Q3ListBoxItem *old = d->current; + if (!old) { + setCurrentItem(d->head); + if (d->selectionMode == Single) + setSelected(d->head, true); + e->ignore(); + return; + } + + bool selectCurrent = false; + switch (e->key()) { + case Qt::Key_Up: + { + d->currInputString.clear(); + if (currentItem() > 0) { + setCurrentItem(currentItem() - 1); + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = d->current; + } + break; + case Qt::Key_Down: + { + d->currInputString.clear(); + if (currentItem() < (int)count() - 1) { + setCurrentItem(currentItem() + 1); + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = d->current; + } + break; + case Qt::Key_Left: + { + d->currInputString.clear(); + if (currentColumn() > 0) { + setCurrentItem(currentItem() - numRows()); + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } else if (numColumns() > 1 && currentItem() > 0) { + int row = currentRow(); + setCurrentItem(currentRow() - 1 + (numColumns() - 1) * numRows()); + + if (currentItem() == -1) + setCurrentItem(row - 1 + (numColumns() - 2) * numRows()); + + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } else { + QApplication::sendEvent(horizontalScrollBar(), e); + } + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = d->current; + } + break; + case Qt::Key_Right: + { + d->currInputString.clear(); + if (currentColumn() < numColumns()-1) { + int row = currentRow(); + int i = currentItem(); + Q3ListBoxItem *it = item(i + numRows()); + if (!it) + it = item(count()-1); + setCurrentItem(it); + + if (currentItem() == -1) { + if (row < numRows() - 1) + setCurrentItem(row + 1); + else + setCurrentItem(i); + } + + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } else if (numColumns() > 1 && currentRow() < numRows()) { + if (currentRow() + 1 < numRows()) { + setCurrentItem(currentRow() + 1); + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + } + } else { + QApplication::sendEvent(horizontalScrollBar(), e); + } + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = d->current; + } + break; + case Qt::Key_Next: + { + d->currInputString.clear(); + int i = 0; + if (numColumns() == 1) { + i = currentItem() + numItemsVisible(); + i = i > (int)count() - 1 ? (int)count() - 1 : i; + setCurrentItem(i); + setBottomItem(i); + } else { + // I'm not sure about this behavior... + if (currentRow() == numRows() - 1) + i = currentItem() + numRows(); + else + i = currentItem() + numRows() - currentRow() - 1; + i = i > (int)count() - 1 ? (int)count() - 1 : i; + setCurrentItem(i); + } + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = d->current; + } + break; + case Qt::Key_Prior: + { + selectCurrent = true; + d->currInputString.clear(); + int i; + if (numColumns() == 1) { + i = currentItem() - numItemsVisible(); + i = i < 0 ? 0 : i; + setCurrentItem(i); + setTopItem(i); + } else { + // I'm not sure about this behavior... + if (currentRow() == 0) + i = currentItem() - numRows(); + else + i = currentItem() - currentRow(); + i = i < 0 ? 0 : i; + setCurrentItem(i); + } + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = d->current; + } + break; + case Qt::Key_Space: + { + selectCurrent = true; + d->currInputString.clear(); + toggleCurrentItem(); + if (selectionMode() == Extended && d->current->isSelected()) + emit highlighted(currentItem()); + if (selfCheck && (!(e->state() & Qt::ShiftButton) || !d->selectAnchor)) + d->selectAnchor = d->current; + } + break; + case Qt::Key_Return: + case Qt::Key_Enter: + { + selectCurrent = true; + d->currInputString.clear(); + if (currentItem() >= 0 && selectionMode() != NoSelection) { + QString tmp = item(currentItem())->text(); + emit selected(currentItem()); + emit selected(item(currentItem())); + if (!tmp.isEmpty()) + emit selected(tmp); + emit returnPressed(item(currentItem())); + } + if (selfCheck && (!(e->state() & Qt::ShiftButton) || !d->selectAnchor)) + d->selectAnchor = d->current; + } + break; + case Qt::Key_Home: + { + selectCurrent = true; + d->currInputString.clear(); + setCurrentItem(0); + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = d->current; + } + break; + case Qt::Key_End: + { + selectCurrent = true; + d->currInputString.clear(); + int i = (int)count() - 1; + setCurrentItem(i); + handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton); + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = d->current; + } + break; + default: + { + if (!e->text().isEmpty() && e->text()[0].isPrint() && count()) { + int curItem = currentItem(); + if (curItem == -1) + curItem = 0; + if (!d->inputTimer->isActive()) { + d->currInputString = e->text(); + curItem = d->findItemByName(++curItem, d->currInputString); + } else { + d->inputTimer->stop(); + d->currInputString += e->text(); + int oldCurItem = curItem; + curItem = d->findItemByName(curItem, d->currInputString); + if (curItem < 0) { + curItem = d->findItemByName(++oldCurItem, e->text()); + d->currInputString = e->text(); + } + } + if (curItem >= 0) + setCurrentItem(curItem); + if (curItem >= 0 && selectionMode() == Q3ListBox::Extended) { + bool changed = false; + bool block = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(block); + Q3ListBoxItem *i = item(curItem); + if (!i->s && i->isSelectable()) { + changed = true; + i->s = true; + updateItem(i); + } + if (changed) + emit selectionChanged(); + } + d->inputTimer->start(400, true); + } else { + d->currInputString.clear(); + if (e->state() & Qt::ControlButton) { + switch (e->key()) { + case Qt::Key_A: + selectAll(true); + break; + } + } else { + e->ignore(); + } + } + } + } + + if (selfCheck && selectCurrent && selectionMode() == Single && + d->current && !d->current->s) { + updateItem(d->current); + setSelected(d->current, true); + } +} + + +/*!\reimp +*/ +void Q3ListBox::focusInEvent(QFocusEvent *e) +{ + d->mousePressRow = -1; + d->mousePressColumn = -1; + d->inMenuMode = false; + if (e->reason() != Qt::MouseFocusReason && !d->current && d->head) { + d->current = d->head; + Q3ListBoxItem *i = d->current; + QString tmp; + if (i) + tmp = i->text(); + int tmp2 = index(i); + emit highlighted(i); + if (!tmp.isNull()) + emit highlighted(tmp); + emit highlighted(tmp2); + emit currentChanged(i); + } + if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) + repaintSelection(); + + if (d->current) + updateItem(currentItem()); +} + + +/*!\reimp +*/ +void Q3ListBox::focusOutEvent(QFocusEvent *e) +{ + if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) { + d->inMenuMode = + e->reason() == Qt::PopupFocusReason || + (qApp->focusWidget() && qApp->focusWidget()->inherits("QMenuBar")); + if (!d->inMenuMode) + repaintSelection(); + } + + if (d->current) + updateItem(currentItem()); +} + +/*!\reimp +*/ +bool Q3ListBox::eventFilter(QObject *o, QEvent *e) +{ + return Q3ScrollView::eventFilter(o, e); +} + +/*! + Repaints the item at position \a index in the list. +*/ + +void Q3ListBox::updateItem(int index) +{ + if (index >= 0) + updateItem(item(index)); +} + + +/*! + \overload + + Repaints the Q3ListBoxItem \a i. +*/ + +void Q3ListBox::updateItem(Q3ListBoxItem * i) +{ + if (!i) + return; + i->dirty = true; + d->updateTimer->start(0, true); +} + + +/*! + \property Q3ListBox::selectionMode + \brief the selection mode of the list box + + Sets the list box's selection mode, which may be one of \c Single + (the default), \c Extended, \c Multi or \c NoSelection. + + \sa SelectionMode +*/ + +void Q3ListBox::setSelectionMode(SelectionMode mode) +{ + if (d->selectionMode == mode) + return; + + if ((selectionMode() == Multi || selectionMode() == Extended) + && (mode == Q3ListBox::Single || mode == Q3ListBox::NoSelection)){ + clearSelection(); + if ((mode == Q3ListBox::Single) && currentItem()) + setSelected(currentItem(), true); + } + + d->selectionMode = mode; + triggerUpdate(true); +} + + +Q3ListBox::SelectionMode Q3ListBox::selectionMode() const +{ + return d->selectionMode; +} + + +/*! + \property Q3ListBox::multiSelection + \brief whether or not the list box is in Multi selection mode + + Consider using the \l Q3ListBox::selectionMode property instead of + this property. + + When setting this property, Multi selection mode is used if set to true and + to Single selection mode if set to false. + + When getting this property, true is returned if the list box is in + Multi selection mode or Extended selection mode, and false if it is + in Single selection mode or NoSelection mode. + + \sa selectionMode +*/ + +bool Q3ListBox::isMultiSelection() const +{ + return selectionMode() == Multi || selectionMode() == Extended; +} + +void Q3ListBox::setMultiSelection(bool enable) +{ + setSelectionMode(enable ? Multi : Single); +} + + +/*! + Toggles the selection status of currentItem() and repaints if the + list box is a \c Multi selection list box. + + \sa setMultiSelection() +*/ + +void Q3ListBox::toggleCurrentItem() +{ + if (selectionMode() == Single || + selectionMode() == NoSelection || + !d->current) + return; + + if (d->current->s || d->current->isSelectable()) { + d->current->s = !d->current->s; + emit selectionChanged(); +#ifndef QT_NO_ACCESSIBILITY + int ind = index(d->current); + QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection); + QAccessible::updateAccessibility(viewport(), ind+1, QAccessible::StateChanged); + QAccessible::updateAccessibility(viewport(), ind+1, d->current->s ? QAccessible::SelectionAdd : QAccessible::SelectionRemove); +#endif + } + updateItem(d->current); +} + + +/*! + \overload + + If \a select is true the item at position \a index is selected; + otherwise the item is deselected. +*/ + +void Q3ListBox::setSelected(int index, bool select) +{ + setSelected(item(index), select); +} + + +/*! + Selects \a item if \a select is true or unselects it if \a select + is false, and repaints the item appropriately. + + If the list box is a \c Single selection list box and \a select is + true, setSelected() calls setCurrentItem(). + + If the list box is a \c Single selection list box, \a select is + false, setSelected() calls clearSelection(). + + \sa setMultiSelection(), setCurrentItem(), clearSelection(), currentItem() +*/ + +void Q3ListBox::setSelected(Q3ListBoxItem * item, bool select) +{ + if (!item || !item->isSelectable() || + (bool)item->s == select || d->selectionMode == NoSelection) + return; + + int ind = index(item); + bool emitHighlighted = (d->current != item) || ( select && (item->s != (uint) select) ); + if (selectionMode() == Single) { + if (d->current != item) { + Q3ListBoxItem *o = d->current; + if (d->current && d->current->s) + d->current->s = false; + d->current = item; +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), ind+1, QAccessible::Focus); +#endif + d->currentColumn = ind / numRows(); + d->currentRow = ind % numRows(); + + if (o) + updateItem(o); + } + } + + item->s = (uint)select; + updateItem(item); + + if (d->selectionMode == Single && select) { + emit selectionChanged(item); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), ind+1, QAccessible::StateChanged); +#endif + } + emit selectionChanged(); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection); + if (d->selectionMode != Single) + QAccessible::updateAccessibility(viewport(), ind+1, select ? QAccessible::SelectionAdd : QAccessible::SelectionRemove); +#endif + + if (emitHighlighted) { + QString tmp; + if (item) + tmp = item->text(); + int tmp2 = index(item); + emit highlighted(item); + if (!tmp.isNull()) + emit highlighted(tmp); + emit highlighted(tmp2); + emit currentChanged(item); + } +} + + +/*! + Returns true if item \a i is selected; otherwise returns false. +*/ + +bool Q3ListBox::isSelected(int i) const +{ + if (selectionMode() == Single && i != currentItem()) + return false; + + Q3ListBoxItem * lbi = item(i); + if (!lbi) + return false; // should not happen + return lbi->s; +} + + +/*! + \overload + + Returns true if item \a i is selected; otherwise returns false. +*/ + +bool Q3ListBox::isSelected(const Q3ListBoxItem * i) const +{ + if (!i) + return false; + + return i->s; +} + +/*! Returns the selected item if the list box is in +single-selection mode and an item is selected. + +If no items are selected or the list box is in another selection mode +this function returns 0. + +\sa setSelected() setMultiSelection() +*/ + +Q3ListBoxItem* Q3ListBox::selectedItem() const +{ + if (d->selectionMode != Single) + return 0; + if (isSelected(currentItem())) + return d->current; + return 0; +} + + +/*! + Deselects all items, if possible. + + Note that a \c Single selection list box will automatically select + an item if it has keyboard focus. +*/ + +void Q3ListBox::clearSelection() +{ + selectAll(false); +} + +/*! + In \c Multi and \c Extended modes, this function sets all items to + be selected if \a select is true, and to be unselected if \a + select is false. + + In \c Single and \c NoSelection modes, this function only changes + the selection status of currentItem(). +*/ + +void Q3ListBox::selectAll(bool select) +{ + if (selectionMode() == Multi || selectionMode() == Extended) { + bool b = signalsBlocked(); + blockSignals(true); + for (int i = 0; i < (int)count(); i++) + setSelected(i, select); + blockSignals(b); + emit selectionChanged(); + } else if (d->current) { + Q3ListBoxItem * i = d->current; + setSelected(i, select); + } +} + +/*! + Inverts the selection. Only works in \c Multi and \c Extended + selection mode. +*/ + +void Q3ListBox::invertSelection() +{ + if (d->selectionMode == Single || + d->selectionMode == NoSelection) + return; + + bool b = signalsBlocked(); + blockSignals(true); + for (int i = 0; i < (int)count(); i++) + setSelected(i, !item(i)->isSelected()); + blockSignals(b); + emit selectionChanged(); +} + + +/*! + Not used anymore; provided for compatibility. +*/ + +void Q3ListBox::emitChangedSignal(bool) +{ +} + + +/*! \reimp */ + +QSize Q3ListBox::sizeHint() const +{ + if (cachedSizeHint().isValid()) + return cachedSizeHint(); + + ensurePolished(); + doLayout(); + + int i=0; + while(i < 10 && + i < (int)d->columnPos.size()-1 && + d->columnPos[i] < 200) + i++; + int x; + x = qMin(200, d->columnPos[i] + + 2 * style()->pixelMetric(QStyle::PM_DefaultFrameWidth)); + x = qMax(40, x); + + i = 0; + while(i < 10 && + i < (int)d->rowPos.size()-1 && + d->rowPos[i] < 200) + i++; + int y; + y = qMin(200, d->rowPos[i] + + 2 * style()->pixelMetric(QStyle::PM_DefaultFrameWidth)); + y = qMax(40, y); + + QSize s(x, y); + setCachedSizeHint(s); + return s; +} + +/*! + \reimp +*/ + +QSize Q3ListBox::minimumSizeHint() const +{ + return Q3ScrollView::minimumSizeHint(); +} + + +/*! + Ensures that a single paint event will occur at the end of the + current event loop iteration. If \a doLayout is true, the layout + is also redone. +*/ + +void Q3ListBox::triggerUpdate(bool doLayout) +{ + if (doLayout) + d->layoutDirty = d->mustPaintAll = true; + d->updateTimer->start(0, true); +} + + +void Q3ListBox::setColumnMode(LayoutMode mode) +{ + if (mode == Variable) + return; + d->rowModeWins = false; + d->columnMode = mode; + triggerUpdate(true); +} + + +void Q3ListBox::setColumnMode(int columns) +{ + if (columns < 1) + columns = 1; + d->columnMode = FixedNumber; + d->numColumns = columns; + d->rowModeWins = false; + triggerUpdate(true); +} + +void Q3ListBox::setRowMode(LayoutMode mode) +{ + if (mode == Variable) + return; + d->rowModeWins = true; + d->rowMode = mode; + triggerUpdate(true); +} + + +void Q3ListBox::setRowMode(int rows) +{ + if (rows < 1) + rows = 1; + d->rowMode = FixedNumber; + d->numRows = rows; + d->rowModeWins = true; + triggerUpdate(true); +} + +/*! + \property Q3ListBox::columnMode + \brief the column layout mode for this list box. + + setColumnMode() sets the layout mode and adjusts the number of + displayed columns. The row layout mode automatically becomes \c + Variable, unless the column mode is \c Variable. + + \sa setRowMode() rowMode numColumns +*/ + + +Q3ListBox::LayoutMode Q3ListBox::columnMode() const +{ + if (d->rowModeWins) + return Variable; + else + return d->columnMode; +} + + +/*! + \property Q3ListBox::rowMode + \brief the row layout mode for this list box + + This property is normally \c Variable. + + setRowMode() sets the layout mode and adjusts the number of + displayed rows. The column layout mode automatically becomes \c + Variable, unless the row mode is \c Variable. + + \sa columnMode +*/ + + +Q3ListBox::LayoutMode Q3ListBox::rowMode() const +{ + if (d->rowModeWins) + return d->rowMode; + else + return Variable; +} + + +/*! + \property Q3ListBox::numColumns + \brief the number of columns in the list box + + This is normally 1, but can be different if \l + Q3ListBox::columnMode or \l Q3ListBox::rowMode has been set. + + \sa columnMode rowMode numRows +*/ + +int Q3ListBox::numColumns() const +{ + if (count() == 0) + return 0; + if (!d->rowModeWins && d->columnMode == FixedNumber) + return d->numColumns; + doLayout(); + return d->columnPos.size()-1; +} + + +/*! + \property Q3ListBox::numRows + \brief the number of rows in the list box. + + This is equal to the number of items in the default single-column + layout, but can be different. + + \sa columnMode rowMode numColumns +*/ + +int Q3ListBox::numRows() const +{ + if (count() == 0) + return 0; + if (d->rowModeWins && d->rowMode == FixedNumber) + return d->numRows; + doLayout(); + return d->rowPos.size()-1; +} + + +/*! + This function does the hard layout work. You should never need to + call it. +*/ + +void Q3ListBox::doLayout() const +{ + if (!d->layoutDirty || d->resizeTimer->isActive()) + return; + ensurePolished(); + int c = count(); + switch(rowMode()) { + case FixedNumber: + // columnMode() is known to be Variable + tryGeometry(d->numRows, (c+d->numRows-1)/d->numRows); + break; + case FitToHeight: + // columnMode() is known to be Variable + if (d->head) { + // this is basically the FitToWidth code, but edited to use rows. + int maxh = 0; + Q3ListBoxItem * i = d->head; + while (i) { + int h = i->height(this); + if (maxh < h) + maxh = h; + i = i->n; + } + int vh = viewportSize(1, 1).height(); + do { + int rows = vh / maxh; + if (rows > c) + rows = c; + if (rows < 1) + rows = 1; + if (variableHeight() && rows < c) { + do { + ++rows; + tryGeometry(rows, (c+rows-1)/rows); + } while (rows <= c && + d->rowPos[(int)d->rowPos.size()-1] <= vh); + --rows; + } + tryGeometry(rows, (c+rows-1)/rows); + int nvh = viewportSize(d->columnPos[(int)d->columnPos.size()-1], + d->rowPos[(int)d->rowPos.size()-1]).height(); + if (nvh < vh) + vh = nvh; + } while (d->rowPos.size() > 2 && + vh < d->rowPos[(int)d->rowPos.size()-1]); + } else { + tryGeometry(1, 1); + } + break; + case Variable: + if (columnMode() == FixedNumber) { + tryGeometry((count()+d->numColumns-1)/d->numColumns, + d->numColumns); + } else if (d->head) { // FitToWidth, at least one item + int maxw = 0; + Q3ListBoxItem * i = d->head; + while (i) { + int w = i->width(this); + if (maxw < w) + maxw = w; + i = i->n; + } + int vw = viewportSize(1, 1).width(); + do { + int cols = vw / maxw; + if (cols > c) + cols = c; + if (cols < 1) + cols = 1; + if (variableWidth() && cols < c) { + do { + ++cols; + tryGeometry((c+cols-1)/cols, cols); + } while (cols <= c && + d->columnPos[(int)d->columnPos.size()-1] <= vw); + --cols; + } + tryGeometry((c+cols-1)/cols, cols); + int nvw = viewportSize(d->columnPos[(int)d->columnPos.size()-1], + d->rowPos[(int)d->rowPos.size()-1]).width(); + if (nvw < vw) + vw = nvw; + } while (d->columnPos.size() > 2 && + vw < d->columnPos[(int)d->columnPos.size()-1]); + } else { + tryGeometry(1, 1); + } + break; + } + + d->layoutDirty = false; + int w = d->columnPos[(int)d->columnPos.size()-1]; + int h = d->rowPos[(int)d->rowPos.size()-1]; + QSize s(viewportSize(w, h)); + w = qMax(w, s.width()); + + d->columnPosOne = d->columnPos[1]; + // extend the column for simple single-column listboxes + if (columnMode() == FixedNumber && d->numColumns == 1 && + d->columnPos[1] < w) + d->columnPos[1] = w; + ((Q3ListBox *)this)->resizeContents(w, h); +} + + +/*! + Lay the items out in a \a columns by \a rows array. The array may + be too big: doLayout() is expected to call this with the right + values. +*/ + +void Q3ListBox::tryGeometry(int rows, int columns) const +{ + if (columns < 1) + columns = 1; + d->columnPos.resize(columns+1); + + if (rows < 1) + rows = 1; + d->rowPos.resize(rows+1); + + // funky hack I: dump the height/width of each column/row in + // {column,row}Pos for later conversion to positions. + int c; + for(c=0; c<=columns; c++) + d->columnPos[c] = 0; + int r; + for(r=0; r<=rows; r++) + d->rowPos[r] = 0; + r = c = 0; + Q3ListBoxItem * i = d->head; + while (i && c < columns) { + if (i == d->current) { + d->currentRow = r; + d->currentColumn = c; + } + + int w = i->width(this); + if (d->columnPos[c] < w) + d->columnPos[c] = w; + int h = i->height(this); + if (d->rowPos[r] < h) + d->rowPos[r] = h; + i = i->n; + r++; + if (r == rows) { + r = 0; + c++; + } + } + // funky hack II: if not variable {width,height}, unvariablify it. + if (!variableWidth()) { + int w = 0; + for(c=0; c<columns; c++) + if (w < d->columnPos[c]) + w = d->columnPos[c]; + for(c=0; c<columns; c++) + d->columnPos[c] = w; + } + if (!variableHeight()) { + int h = 0; + for(r=0; r<rows; r++) + if (h < d->rowPos[r]) + h = d->rowPos[r]; + for(r=0; r<rows; r++) + d->rowPos[r] = h; + } + // repair the hacking. + int x = 0; + for(c=0; c<=columns; c++) { + int w = d->columnPos[c]; + d->columnPos[c] = x; + x += w; + } + int y = 0; + for(r=0; r<=rows; r++) { + int h = d->rowPos[r]; + d->rowPos[r] = y; + y += h; + } +} + + +/*! + Returns the row index of the current item, or -1 if no item is the + current item. +*/ + +int Q3ListBox::currentRow() const +{ + if (!d->current) + return -1; + if (d->currentRow < 0) + d->layoutDirty = true; + if (d->layoutDirty) + doLayout(); + return d->currentRow; +} + + +/*! + Returns the column index of the current item, or -1 if no item is + the current item. +*/ + +int Q3ListBox::currentColumn() const +{ + if (!d->current) + return -1; + if (d->currentColumn < 0) + d->layoutDirty = true; + if (d->layoutDirty) + doLayout(); + return d->currentColumn; +} + + +void Q3ListBox::setTopItem(int index) +{ + if (index >= (int)count() || count() == 0) + return; + int col = index / numRows(); + int y = d->rowPos[index-col*numRows()]; + if (d->columnPos[col] >= contentsX() && + d->columnPos[col+1] <= contentsX() + visibleWidth()) + setContentsPos(contentsX(), y); + else + setContentsPos(d->columnPos[col], y); +} + +/*! + Scrolls the list box so the item at position \a index in the list + is displayed in the bottom row of the list box. + + \sa setTopItem() +*/ + +void Q3ListBox::setBottomItem(int index) +{ + if (index >= (int)count() || count() == 0) + return; + int col = index / numRows(); + int y = d->rowPos[1+index-col*numRows()] - visibleHeight(); + if (y < 0) + y = 0; + if (d->columnPos[col] >= contentsX() && + d->columnPos[col+1] <= contentsX() + visibleWidth()) + setContentsPos(contentsX(), y); + else + setContentsPos(d->columnPos[col], y); +} + + +/*! + Returns the item at point \a p, specified in viewport coordinates, + or a 0 if there is no item at \a p. + + Use contentsToViewport() to convert between widget coordinates and + viewport coordinates. +*/ + +Q3ListBoxItem * Q3ListBox::itemAt(const QPoint& p) const +{ + if (d->layoutDirty) + doLayout(); + QPoint np = p; + + np -= viewport()->pos(); + if (!viewport()->rect().contains(np)) + return 0; + + // take into account contents position + np = viewportToContents(np); + + int x = np.x(); + int y = np.y(); + + // return 0 when y is below the last row + if (y > d->rowPos[numRows()]) + return 0; + + int col = columnAt(x); + int row = rowAt(y); + + Q3ListBoxItem *i = item(col * numRows() + row); + if (i && numColumns() > 1) { + if (d->columnPos[col] + i->width(this) >= x) + return i; + } else { + if (d->columnPos[col + 1] >= x) + return i; + } + return 0; +} + + +/*! + Ensures that the current item is visible. +*/ + +void Q3ListBox::ensureCurrentVisible() +{ + if (!d->current) + return; + + doLayout(); + + int row = currentRow(); + int column = currentColumn(); + int w = (d->columnPos[column+1] - d->columnPos[column]) / 2; + int h = (d->rowPos[row+1] - d->rowPos[row]) / 2; + // next four lines are Bad. they mean that for pure left-to-right + // languages, textual list box items are displayed better than + // before when there is little space. for non-textual items, or + // other languages, it means... that you really should have enough + // space in the first place :) + if (numColumns() == 1) + w = 0; + if (w*2 > viewport()->width()) + w = viewport()->width()/2; + + ensureVisible(d->columnPos[column] + w, d->rowPos[row] + h, w, h); +} + + +/*! \internal */ + +void Q3ListBox::doAutoScroll() +{ + if (d->scrollPos.x() < 0) { + // scroll left + int x = contentsX() - horizontalScrollBar()->singleStep(); + if (x < 0) + x = 0; + if (x != contentsX()) { + d->mouseMoveColumn = columnAt(x); + updateSelection(); + if (x < contentsX()) + setContentsPos(x, contentsY()); + } + } else if (d->scrollPos.x() > 0) { + // scroll right + int x = contentsX() + horizontalScrollBar()->singleStep(); + if (x + visibleWidth() > contentsWidth()) + x = contentsWidth() - visibleWidth(); + if (x != contentsX()) { + d->mouseMoveColumn = columnAt(x + visibleWidth() - 1); + updateSelection(); + if (x > contentsX()) + setContentsPos(x, contentsY()); + } + } + + if (d->scrollPos.y() < 0) { + // scroll up + int y = contentsY() - verticalScrollBar()->singleStep(); + if (y < 0) + y = 0; + if (y != contentsY()) { + y = contentsY() - verticalScrollBar()->singleStep(); + d->mouseMoveRow = rowAt(y); + updateSelection(); + } + } else if (d->scrollPos.y() > 0) { + // scroll down + int y = contentsY() + verticalScrollBar()->singleStep(); + if (y + visibleHeight() > contentsHeight()) + y = contentsHeight() - visibleHeight(); + if (y != contentsY()) { + y = contentsY() + verticalScrollBar()->singleStep(); + d->mouseMoveRow = rowAt(y + visibleHeight() - 1); + updateSelection(); + } + } + + if (d->scrollPos == QPoint(0, 0)) { + delete d->scrollTimer; + d->scrollTimer = 0; + } +} + + +/*! + \property Q3ListBox::topItem + \brief the index of an item at the top of the screen. + + When getting this property and the listbox has multiple columns, + an arbitrary item is selected and returned. + + When setting this property, the list box is scrolled so the item + at position \e index in the list is displayed in the top row of + the list box. +*/ + +int Q3ListBox::topItem() const +{ + doLayout(); + + // move rightwards to the best column + int col = columnAt(contentsX()); + int row = rowAt(contentsY()); + return col * numRows() + row; +} + + +/*! + \property Q3ListBox::variableHeight + \brief whether this list box has variable-height rows + + When the list box has variable-height rows (the default), each row + is as high as the highest item in that row. When it has same-sized + rows, all rows are as high as the highest item in the list box. + + \sa variableWidth +*/ + +bool Q3ListBox::variableHeight() const +{ + return d->variableHeight; +} + + +void Q3ListBox::setVariableHeight(bool enable) +{ + if ((bool)d->variableHeight == enable) + return; + + d->variableHeight = enable; + triggerUpdate(true); +} + + +/*! + \property Q3ListBox::variableWidth + \brief whether this list box has variable-width columns + + When the list box has variable-width columns, each column is as + wide as the widest item in that column. When it has same-sized + columns (the default), all columns are as wide as the widest item + in the list box. + + \sa variableHeight +*/ + +bool Q3ListBox::variableWidth() const +{ + return d->variableWidth; +} + + +void Q3ListBox::setVariableWidth(bool enable) +{ + if ((bool)d->variableWidth == enable) + return; + + d->variableWidth = enable; + triggerUpdate(true); +} + + +/*! + Repaints only what really needs to be repainted. +*/ +void Q3ListBox::refreshSlot() +{ + if (d->mustPaintAll || + d->layoutDirty) { + d->mustPaintAll = false; + bool currentItemVisible = itemVisible(currentItem()); + doLayout(); + if (hasFocus() && + currentItemVisible && + d->currentColumn >= 0 && + d->currentRow >= 0 && + (d->columnPos[d->currentColumn] < contentsX() || + d->columnPos[d->currentColumn+1]>contentsX()+visibleWidth() || + d->rowPos[d->currentRow] < contentsY() || + d->rowPos[d->currentRow+1] > contentsY()+visibleHeight())) + ensureCurrentVisible(); + viewport()->repaint(); + return; + } + + QRegion r; + int x = contentsX(); + int y = contentsY(); + int col = columnAt(x); + int row = rowAt(y); + int top = row; + while(col < (int)d->columnPos.size()-1 && d->columnPos[col+1] < x) + col++; + while(top < (int)d->rowPos.size()-1 && d->rowPos[top+1] < y) + top++; + Q3ListBoxItem * i = item(col * numRows() + row); + + while (i && (int)col < numColumns() && + d->columnPos[col] < x + visibleWidth() ) { + int cw = d->columnPos[col+1] - d->columnPos[col]; + while (i && row < numRows() && d->rowPos[row] < + y + visibleHeight()) { + if (i->dirty) + r = r.united(QRect(d->columnPos[col] - x, d->rowPos[row] - y, + cw, d->rowPos[row+1] - d->rowPos[row])); + row++; + i = i->n; + } + col++; + if (numColumns() > 1) { + row = top; + i = item(col * numRows() + row); + } + } + + if (r.isEmpty()) + viewport()->repaint(); + else + viewport()->repaint(r); +} + + +/*! \reimp */ + +void Q3ListBox::viewportPaintEvent(QPaintEvent * e) +{ + doLayout(); + QWidget* vp = viewport(); + QPainter p(vp); + QRegion r = e->region(); + +#if 0 + { + // this stuff has been useful enough times that from now I'm + // leaving it in the source. + uint i = 0; + qDebug("%s/%s: %i rects", className(), name(), r.rects().size()); + while(i < r.rects().size()) { + qDebug("rect %d: %d, %d, %d, %d", i, + r.rects()[i].left(), r.rects()[i].top(), + r.rects()[i].width(), r.rects()[i].height()); + i++; + } + qDebug(""); + } +#endif + + int x = contentsX(); + int y = contentsY(); + int w = vp->width(); + int h = vp->height(); + + int col = columnAt(x); + int top = rowAt(y); + int row = top; + + Q3ListBoxItem * i = item(col*numRows() + row); + + const QPalette &pal = palette(); + p.setPen(pal.text().color()); + p.setBackground(palette().brush(backgroundRole()).color()); + while (i && (int)col < numColumns() && d->columnPos[col] < x + w) { + int cw = d->columnPos[col+1] - d->columnPos[col]; + while (i && (int)row < numRows() && d->rowPos[row] < y + h) { + int ch = d->rowPos[row+1] - d->rowPos[row]; + QRect itemRect(d->columnPos[col]-x, d->rowPos[row]-y, cw, ch); + QRegion tempRegion(itemRect); + QRegion itemPaintRegion(tempRegion.intersected(r )); + if (!itemPaintRegion.isEmpty()) { + p.save(); + p.setClipRegion(itemPaintRegion); + p.translate(d->columnPos[col]-x, d->rowPos[row]-y); + paintCell(&p, row, col); + p.restore(); + r = r.subtracted(itemPaintRegion); + } + row++; + if (i->dirty) { + // reset dirty flag only if the entire item was painted + if (itemPaintRegion == QRegion(itemRect)) + i->dirty = false; + } + i = i->n; + } + col++; + if (numColumns() > 1) { + row = top; + i = item(col * numRows() + row); + } + } + + if (r.isEmpty()) + return; + p.setClipRegion(r); + p.fillRect(0, 0, w, h, viewport()->palette().brush(viewport()->backgroundRole())); + + if(d->rubber && d->rubber->width() && d->rubber->height()) { + p.save(); + p.setClipping(false); + // p.setRasterOp(NotROP); // ### fix - use qrubberband instead + QStyleOptionRubberBand opt; + opt.rect = d->rubber->normalized(); + opt.palette = palette(); + opt.shape = QRubberBand::Rectangle; + opt.opaque = false; + style()->drawControl(QStyle::CE_RubberBand, &opt, &p, this); + p.restore(); + } +} + + +/*! + Returns the height in pixels of the item with index \a index. \a + index defaults to 0. + + If \a index is too large, this function returns 0. +*/ + +int Q3ListBox::itemHeight(int index) const +{ + if (index >= (int)count() || index < 0) + return 0; + int r = index % numRows(); + return d->rowPos[r+1] - d->rowPos[r]; +} + + +/*! + Returns the index of the column at \a x, which is in the listbox's + coordinates, not in on-screen coordinates. + + If there is no column that spans \a x, columnAt() returns -1. +*/ + +int Q3ListBox::columnAt(int x) const +{ + if (x < 0) + return -1; + if (!d->columnPos.size()) + return -1; + if (x >= d->columnPos[(int)d->columnPos.size()-1]) + return numColumns() - 1; + + int col = 0; + while(col < (int)d->columnPos.size()-1 && d->columnPos[col+1] < x) + col++; + return col; +} + + +/*! + Returns the index of the row at \a y, which is in the listbox's + coordinates, not in on-screen coordinates. + + If there is no row that spans \a y, rowAt() returns -1. +*/ + +int Q3ListBox::rowAt(int y) const +{ + if (y < 0) + return -1; + + // find the top item, use bsearch for speed + int l = 0; + int r = d->rowPos.size() - 2; + if (r < 0) + return -1; + if (l <= d->rowPosCache && d->rowPosCache <= r) { + if (d->rowPos[qMax(l, d->rowPosCache - 10)] <= y + && y <= d->rowPos[qMin(r, d->rowPosCache + 10)]) { + l = qMax(l, d->rowPosCache - 10); + r = qMin(r, d->rowPosCache + 10); + } + } + int i = ((l+r+1) / 2); + while (r - l) { + if (d->rowPos[i] > y) + r = i -1; + else + l = i; + i = ((l+r+1) / 2); + } + d->rowPosCache = i; + if (d->rowPos[i] <= y && y <= d->rowPos[i+1] ) + return i; + + return d->count - 1; +} + + +/*! + Returns the rectangle on the screen that \a item occupies in + viewport()'s coordinates, or an invalid rectangle if \a item is 0 + or is not currently visible. +*/ + +QRect Q3ListBox::itemRect(Q3ListBoxItem *item) const +{ + if (d->resizeTimer->isActive()) + return QRect(0, 0, -1, -1); + if (!item) + return QRect(0, 0, -1, -1); + + int i = index(item); + if (i == -1) + return QRect(0, 0, -1, -1); + + int col = i / numRows(); + int row = i % numRows(); + + int x = d->columnPos[col] - contentsX(); + int y = d->rowPos[row] - contentsY(); + + QRect r(x, y, d->columnPos[col + 1] - d->columnPos[col], + d->rowPos[row + 1] - d->rowPos[row]); + if (r.intersects(QRect(0, 0, visibleWidth(), visibleHeight()))) + return r; + return QRect(0, 0, -1, -1); +} + + +/*! + Using this method is quite inefficient. We suggest to use insertItem() + for inserting and sort() afterwards. + + Inserts \a lbi at its sorted position in the list box and returns the + position. + + All items must be inserted with inSort() to maintain the sorting + order. inSort() treats any pixmap (or user-defined type) as + lexicographically less than any string. + + \sa insertItem(), sort() +*/ +int Q3ListBox::inSort(const Q3ListBoxItem * lbi) +{ + if (!lbi) + return -1; + + Q3ListBoxItem * i = d->head; + int c = 0; + + while(i && i->text() < lbi->text()) { + i = i->n; + c++; + } + insertItem(lbi, c); + return c; +} + +/*! + \overload + Using this method is quite inefficient. We suggest to use insertItem() + for inserting and sort() afterwards. + + Inserts a new item of \a text at its sorted position in the list box and + returns the position. + + All items must be inserted with inSort() to maintain the sorting + order. inSort() treats any pixmap (or user-defined type) as + lexicographically less than any string. + + \sa insertItem(), sort() +*/ +int Q3ListBox::inSort(const QString& text) +{ + Q3ListBoxItem *lbi = new Q3ListBoxText(text); + + Q3ListBoxItem * i = d->head; + int c = 0; + + while(i && i->text() < lbi->text()) { + i = i->n; + c++; + } + insertItem(lbi, c); + return c; +} + + +/*! \reimp */ + +void Q3ListBox::resizeEvent(QResizeEvent *e) +{ + d->layoutDirty = (d->layoutDirty || + rowMode() == FitToHeight || + columnMode() == FitToWidth); + + if (!d->layoutDirty && columnMode() == FixedNumber && + d->numColumns == 1) { + int w = d->columnPosOne; + QSize s(viewportSize(w, contentsHeight())); + w = qMax(w, s.width()); + d->columnPos[1] = qMax(w, d->columnPosOne); + resizeContents(d->columnPos[1], contentsHeight()); + } + + if (d->resizeTimer->isActive()) + d->resizeTimer->stop(); + if (d->rowMode == FixedNumber && d->columnMode == FixedNumber) { + bool currentItemVisible = itemVisible(currentItem()); + doLayout(); + Q3ScrollView::resizeEvent(e); + if (currentItemVisible) + ensureCurrentVisible(); + if (d->current) + viewport()->repaint(itemRect(d->current)); + } else if ((d->columnMode == FitToWidth || d->rowMode == FitToHeight) && !(isVisible())) { + Q3ScrollView::resizeEvent(e); + } else if (d->layoutDirty) { + d->resizeTimer->start(100, true); + resizeContents(contentsWidth() - (e->oldSize().width() - e->size().width()), + contentsHeight() - (e->oldSize().height() - e->size().height())); + Q3ScrollView::resizeEvent(e); + } else { + Q3ScrollView::resizeEvent(e); + } +} + +/*! + \internal +*/ + +void Q3ListBox::adjustItems() +{ + triggerUpdate(true); + ensureCurrentVisible(); +} + + +/*! + Provided for compatibility with the old Q3ListBox. We recommend + using Q3ListBoxItem::paint() instead. + + Repaints the cell at \a row, \a col using painter \a p. +*/ + +void Q3ListBox::paintCell(QPainter * p, int row, int col) +{ + bool drawActiveSelection = hasFocus() || d->inMenuMode || + !style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this); + QPalette pal = palette(); + if(!drawActiveSelection) + pal.setCurrentColorGroup(QPalette::Inactive); + + int cw = d->columnPos[col+1] - d->columnPos[col]; + int ch = d->rowPos[row+1] - d->rowPos[row]; + Q3ListBoxItem * i = item(col*numRows()+row); + p->save(); + if (i->s) { + if (i->custom_highlight) { + p->fillRect(0, 0, cw, ch, pal.brush(viewport()->foregroundRole())); + p->setPen(pal.highlightedText().color()); + p->setBackground(pal.highlight()); + } else if (numColumns() == 1) { + p->fillRect(0, 0, cw, ch, pal.brush(QPalette::Highlight)); + p->setPen(pal.highlightedText().color()); + p->setBackground(pal.highlight()); + } else { + int iw = i->width(this); + p->fillRect(0, 0, iw, ch, pal.brush(QPalette::Highlight)); + p->fillRect(iw, 0, cw - iw + 1, ch, viewport()->palette().brush(viewport()->backgroundRole())); + p->setPen(pal.highlightedText().color()); + p->setBackground(pal.highlight()); + } + } else { + p->fillRect(0, 0, cw, ch, viewport()->palette().brush(viewport()->backgroundRole())); + } + + i->paint(p); + + if (d->current == i && hasFocus() && !i->custom_highlight) { + if (numColumns() > 1) + cw = i->width(this); + QStyleOptionFocusRect opt; + opt.rect.setRect(0, 0, cw, ch); + opt.palette = pal; + opt.state = QStyle::State_FocusAtBorder; + if (i->isSelected()) + opt.backgroundColor = pal.highlight().color(); + else + opt.backgroundColor = pal.base().color(); + style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p, this); + } + + p->restore(); +} + +/*! + Returns the width of the widest item in the list box. +*/ + +long Q3ListBox::maxItemWidth() const +{ + if (d->layoutDirty) + doLayout(); + long m = 0; + int i = d->columnPos.size(); + while(i--) + if (m < d->columnPos[i]) + m = d->columnPos[i]; + return m; +} + + +/*! \reimp */ + +void Q3ListBox::showEvent(QShowEvent *) +{ + d->ignoreMoves = false; + d->mousePressRow = -1; + d->mousePressColumn = -1; + d->mustPaintAll = false; + ensureCurrentVisible(); +} + +/*! + \fn bool Q3ListBoxItem::isSelected() const + + Returns true if the item is selected; otherwise returns false. + + \sa Q3ListBox::isSelected(), isCurrent() +*/ + +/*! + Returns true if the item is the current item; otherwise returns + false. + + \sa Q3ListBox::currentItem(), Q3ListBox::item(), isSelected() +*/ +bool Q3ListBoxItem::isCurrent() const +{ + return listBox() && listBox()->hasFocus() && + listBox()->item(listBox()->currentItem()) == this; +} + +/*! + \fn void Q3ListBox::centerCurrentItem() + + If there is a current item, the list box is scrolled so that this + item is displayed centered. + + \sa Q3ListBox::ensureCurrentVisible() +*/ + +/*! + Returns a pointer to the list box containing this item. +*/ + +Q3ListBox * Q3ListBoxItem::listBox() const +{ + return lbox; +} + + +/*! + Removes \a item from the list box and causes an update of the + screen display. The item is not deleted. You should normally not + need to call this function because Q3ListBoxItem::~Q3ListBoxItem() + calls it. The normal way to delete an item is with \c delete. + + \sa Q3ListBox::insertItem() +*/ +void Q3ListBox::takeItem(const Q3ListBoxItem * item) +{ + if (!item || d->clearing) + return; + d->cache = 0; + d->count--; + if (item == d->last) + d->last = d->last->p; + if (item->p && item->p->n == item) + item->p->n = item->n; + if (item->n && item->n->p == item) + item->n->p = item->p; + if (d->head == item) { + d->head = item->n; + d->currentColumn = d->currentRow = -1; + } + + if (d->current == item) { + d->current = item->n ? item->n : item->p; + Q3ListBoxItem *i = d->current; + QString tmp; + if (i) + tmp = i->text(); + int tmp2 = index(i); + emit highlighted(i); + if (!tmp.isNull()) + emit highlighted(tmp); + emit highlighted(tmp2); + emit currentChanged(i); + } + if (d->tmpCurrent == item) + d->tmpCurrent = d->current; + if (d->selectAnchor == item) + d->selectAnchor = d->current; + + if (item->s) + emit selectionChanged(); + ((Q3ListBoxItem *)item)->lbox = 0; + triggerUpdate(true); +} + +/*! + \internal + Finds the next item after start beginning with \a text. +*/ + +int Q3ListBoxPrivate::findItemByName(int start, const QString &text) +{ + if (start < 0 || (uint)start >= listBox->count()) + start = 0; + QString match = text.toLower(); + if (match.length() < 1) + return start; + QString curText; + int item = start; + do { + curText = listBox->text(item).toLower(); + if (curText.startsWith(match)) + return item; + item++; + if ((uint)item == listBox->count()) + item = 0; + } while (item != start); + return -1; +} + +/*! + \internal +*/ + +void Q3ListBox::clearInputString() +{ + d->currInputString.clear(); +} + +/*! + Finds the first list box item that has the text \a text and + returns it, or returns 0 of no such item could be found. If \c + ComparisonFlags are specified in \a compare then these flags + are used, otherwise the default is a case-insensitive, "begins + with" search. +*/ + +Q3ListBoxItem *Q3ListBox::findItem(const QString &text, ComparisonFlags compare) const +{ + if (text.isEmpty()) + return 0; + + if (compare == CaseSensitive || compare == 0) + compare |= ExactMatch; + + QString itmtxt; + QString comtxt = text; + if (!(compare & CaseSensitive)) + comtxt = text.toLower(); + + Q3ListBoxItem *item; + if (d->current) + item = d->current; + else + item = d->head; + + Q3ListBoxItem *beginsWithItem = 0; + Q3ListBoxItem *endsWithItem = 0; + Q3ListBoxItem *containsItem = 0; + + if (item) { + for (; item; item = item->n) { + if (!(compare & CaseSensitive)) + itmtxt = item->text().toLower(); + else + itmtxt = item->text(); + + if ((compare & ExactMatch)==ExactMatch && itmtxt == comtxt) + return item; + if (compare & BeginsWith && !beginsWithItem && itmtxt.startsWith(comtxt)) + beginsWithItem = containsItem = item; + if (compare & EndsWith && !endsWithItem && itmtxt.endsWith(comtxt)) + endsWithItem = containsItem = item; + if ((compare & ExactMatch)==0 && !containsItem && itmtxt.contains(comtxt)) + containsItem = item; + } + + if (d->current && d->head) { + item = d->head; + for (; item && item != d->current; item = item->n) { + if (!(compare & CaseSensitive)) + itmtxt = item->text().toLower(); + else + itmtxt = item->text(); + + if ((compare & ExactMatch)==ExactMatch && itmtxt == comtxt) + return item; + if (compare & BeginsWith && !beginsWithItem && itmtxt.startsWith(comtxt)) + beginsWithItem = containsItem = item; + if (compare & EndsWith && !endsWithItem && itmtxt.endsWith(comtxt)) + endsWithItem = containsItem = item; + if ((compare & ExactMatch)==0 && !containsItem && itmtxt.contains(comtxt)) + containsItem = item; + } + } + } + + // Obey the priorities + if (beginsWithItem) + return beginsWithItem; + else if (endsWithItem) + return endsWithItem; + else if (containsItem) + return containsItem; + return 0; +} + +/*! + \internal +*/ + +void Q3ListBox::drawRubber() +{ + if (!d->rubber) + return; + if (!d->rubber->width() && !d->rubber->height()) + return; + update(); +} + +/*! + \internal +*/ + +void Q3ListBox::doRubberSelection(const QRect &old, const QRect &rubber) +{ + Q3ListBoxItem *i = d->head; + QRect ir, pr; + bool changed = false; + for (; i; i = i->n) { + ir = itemRect(i); + if (ir == QRect(0, 0, -1, -1)) + continue; + if (i->isSelected() && !ir.intersects(rubber) && ir.intersects(old)) { + i->s = false; + pr = pr.united(ir); + changed = true; + } else if (!i->isSelected() && ir.intersects(rubber)) { + if (i->isSelectable()) { + i->s = true; + pr = pr.united(ir); + changed = true; + } + } + } + if (changed) { + emit selectionChanged(); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection); +#endif + } + viewport()->repaint(pr); +} + + +/*! + Returns true if the user is selecting items using a rubber band + rectangle; otherwise returns false. +*/ + +bool Q3ListBox::isRubberSelecting() const +{ + return d->rubber != 0; +} + + +/*! + Returns the item that comes after this in the list box. If this is + the last item, 0 is returned. + + \sa prev() +*/ + +Q3ListBoxItem *Q3ListBoxItem::next() const +{ + return n; +} + +/*! + Returns the item which comes before this in the list box. If this + is the first item, 0 is returned. + + \sa next() +*/ + +Q3ListBoxItem *Q3ListBoxItem::prev() const +{ + return p; +} + +/*! + Returns the first item in this list box. If the list box is empty, + returns 0. +*/ + +Q3ListBoxItem *Q3ListBox::firstItem() const +{ + return d->head; +} + +#if defined(Q_C_CALLBACKS) +extern "C" { +#endif + +#ifdef Q_OS_WINCE +static int _cdecl cmpListBoxItems(const void *n1, const void *n2) +#else +static int cmpListBoxItems(const void *n1, const void *n2) +#endif +{ + if (!n1 || !n2) + return 0; + + Q3ListBoxPrivate::SortableItem *i1 = (Q3ListBoxPrivate::SortableItem *)n1; + Q3ListBoxPrivate::SortableItem *i2 = (Q3ListBoxPrivate::SortableItem *)n2; + + return i1->item->text().localeAwareCompare(i2->item->text()); +} + +#if defined(Q_C_CALLBACKS) +} +#endif + +/*! + If \a ascending is true sorts the items in ascending order; + otherwise sorts in descending order. + + To compare the items, the text (Q3ListBoxItem::text()) of the items + is used. +*/ + +void Q3ListBox::sort(bool ascending) +{ + if (count() == 0) + return; + + d->cache = 0; + + Q3ListBoxPrivate::SortableItem *items = new Q3ListBoxPrivate::SortableItem[count()]; + + Q3ListBoxItem *item = d->head; + int i = 0; + for (; item; item = item->n) + items[i++].item = item; + + qsort(items, count(), sizeof(Q3ListBoxPrivate::SortableItem), cmpListBoxItems); + + Q3ListBoxItem *prev = 0; + item = 0; + if (ascending) { + for (i = 0; i < (int)count(); ++i) { + item = items[i].item; + if (item) { + item->p = prev; + item->dirty = true; + if (item->p) + item->p->n = item; + item->n = 0; + } + if (i == 0) + d->head = item; + prev = item; + } + } else { + for (i = (int)count() - 1; i >= 0 ; --i) { + item = items[i].item; + if (item) { + item->p = prev; + item->dirty = true; + if (item->p) + item->p->n = item; + item->n = 0; + } + if (i == (int)count() - 1) + d->head = item; + prev = item; + } + } + d->last = item; + + delete [] items; + + // We have to update explicitly in case the current "vieport" overlaps the + // new viewport we set (starting at (0,0)). + bool haveToUpdate = contentsX() < visibleWidth() || contentsY() < visibleHeight(); + setContentsPos(0, 0); + if (haveToUpdate) + updateContents(0, 0, visibleWidth(), visibleHeight()); +} + +void Q3ListBox::handleItemChange(Q3ListBoxItem *old, bool shift, bool control) +{ + if (d->selectionMode == Single) { + // nothing + } else if (d->selectionMode == Extended) { + if (shift) { + selectRange(d->selectAnchor ? d->selectAnchor : old, + d->current, false, true, (d->selectAnchor && !control) ? true : false); + } else if (!control) { + bool block = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(block); + setSelected(d->current, true); + } + } else if (d->selectionMode == Multi) { + if (shift) + selectRange(old, d->current, true, false); + } +} + +void Q3ListBox::selectRange(Q3ListBoxItem *from, Q3ListBoxItem *to, bool invert, bool includeFirst, bool clearSel) +{ + if (!from || !to) + return; + if (from == to && !includeFirst) + return; + Q3ListBoxItem *i = 0; + int index =0; + int f_idx = -1, t_idx = -1; + for (i = d->head; i; i = i->n, index++) { + if (i == from) + f_idx = index; + if (i == to) + t_idx = index; + if (f_idx != -1 && t_idx != -1) + break; + } + if (f_idx > t_idx) { + i = from; + from = to; + to = i; + if (!includeFirst) + to = to->prev(); + } else { + if (!includeFirst) + from = from->next(); + } + + bool changed = false; + if (clearSel) { + for (i = d->head; i && i != from; i = i->n) { + if (i->s) { + i->s = false; + changed = true; + updateItem(i); + } + } + for (i = to->n; i; i = i->n) { + if (i->s) { + i->s = false; + changed = true; + updateItem(i); + } + } + } + + for (i = from; i; i = i->next()) { + if (!invert) { + if (!i->s && i->isSelectable()) { + i->s = true; + changed = true; + updateItem(i); + } + } else { + bool sel = !i->s; + if (((bool)i->s != sel && sel && i->isSelectable()) || !sel) { + i->s = sel; + changed = true; + updateItem(i); + } + } + if (i == to) + break; + } + if (changed) { + emit selectionChanged(); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection); +#endif + } +} + +/*! \reimp */ +void Q3ListBox::changeEvent(QEvent *ev) +{ + if (ev->type() == QEvent::ActivationChange) { + if (!isActiveWindow() && d->scrollTimer) + d->scrollTimer->stop(); + if (!palette().isEqual(QPalette::Active, QPalette::Inactive)) + viewport()->update(); + } + Q3ScrollView::changeEvent(ev); + + if (ev->type() == QEvent::ApplicationFontChange || ev->type() == QEvent::FontChange) + triggerUpdate(true); +} + +/*! + Returns 0. + + Make your derived classes return their own values for rtti(), and + you can distinguish between listbox items. You should use values + greater than 1000 preferably a large random number, to allow for + extensions to this class. +*/ + +int Q3ListBoxItem::rtti() const +{ + return RTTI; +} + +/*! + \fn bool Q3ListBox::dragSelect() const + + Returns true. Dragging always selects. +*/ + +/*! + \fn void Q3ListBox::setDragSelect(bool b) + + Does nothing. Dragging always selects. The \a b parameter is ignored. +*/ + +/*! + \fn bool Q3ListBox::autoScroll() const + + Use dragAutoScroll() instead. This function always returns true. +*/ + +/*! + \fn void Q3ListBox::setAutoScroll(bool b) + + Use setDragAutoScroll(\a b) instead. +*/ + +/*! + \fn bool Q3ListBox::autoScrollBar() const + + Use vScrollBarMode() instead. Returns true if the vertical + scrollbar mode is \c Auto. +*/ + +/*! + \fn void Q3ListBox::setAutoScrollBar(bool enable) + + Use setVScrollBarMode() instead. + + If \a enable is true, pass \c Auto as the argument to + setVScrollBarMode(); otherwise, pass \c AlwaysOff. +*/ + +/*! + \fn bool Q3ListBox::scrollBar() const + + Use vScrollBarMode() instead. Returns true if the vertical + scrollbar mode is not \c AlwaysOff. +*/ + +/*! + \fn void Q3ListBox::setScrollBar(bool enable) + + Use setVScrollBarMode() instead. + + If \a enable is true, pass \c AlwaysOn as the argument to + setVScrollBarMode(); otherwise, pass \c AlwaysOff. +*/ + +/*! + \fn bool Q3ListBox::autoBottomScrollBar() const + + Use hScrollBarMode() instead. Returns true if the horizontal + scrollbar mode is set to \c Auto. +*/ + +/*! + \fn void Q3ListBox::setAutoBottomScrollBar(bool enable) + + Use setHScrollBarMode() instead. + + If \a enable is true, pass \c Auto as the argument to + setHScrollBarMode(); otherwise, pass \c AlwaysOff. +*/ + +/*! + \fn bool Q3ListBox::bottomScrollBar() const + + Use hScrollBarMode() instead. Returns true if the horizontal + scrollbar mode is not \c AlwaysOff. +*/ + +/*! + \fn void Q3ListBox::setBottomScrollBar(bool enable) + + Use setHScrollBarMode() instead. + + If \a enable is true, pass \c AlwaysOn as the argument to + setHScrollBarMode(); otherwise, pass \c AlwaysOff. +*/ + +/*! + \fn bool Q3ListBox::smoothScrolling() const + + Returns false. Qt always scrolls smoothly. +*/ + +/*! + \fn void Q3ListBox::setSmoothScrolling(bool b) + + Does nothing. Qt always scrolls smoothly. The \a b parameter is + ignored. +*/ + +/*! + \fn bool Q3ListBox::autoUpdate() const + + Returns true. Qt always updates automatically. +*/ + +/*! + \fn void Q3ListBox::setAutoUpdate(bool b) + + Does nothing. Qt always updates automatically. The \a b parameter + is ignored. +*/ + +/*! + \fn void Q3ListBox::setFixedVisibleLines(int lines) + + Use setRowMode(\a lines) instead. +*/ + +/*! + \fn int Q3ListBox::cellHeight(int i) const + + Use itemHeight(\a i) instead. +*/ + +/*! + \fn int Q3ListBox::cellHeight() const + + Use itemHeight() instead. +*/ + +/*! + \fn int Q3ListBox::cellWidth() const + + Use maxItemWidth() instead. +*/ + +/*! + \fn int Q3ListBox::cellWidth(int i) const + + Use maxItemWidth(\a i) instead. +*/ + +/*! + \fn int Q3ListBox::numCols() const + + Use numColumns() instead. +*/ + +/*! + \fn void Q3ListBox::updateCellWidth() + + Does nothing. Qt automatically updates. +*/ + +/*! + \fn int Q3ListBox::totalWidth() const + + Use contentsWidth() instead. +*/ + +/*! + \fn int Q3ListBox::totalHeight() const + + Use contentsHeight() instead. +*/ + +/*! + \fn int Q3ListBox::findItem(int yPos) const + + Use index(itemAt(\a yPos)) instead. +*/ + +/*! + \fn bool Q3ListBoxItem::selected() const + + Use isSelected() instead. Returns true if isSelected() + returns true. +*/ + +/*! + \fn bool Q3ListBoxItem::current() const + + Use isCurrent() instead. Returns true if isCurrent() + returns true. +*/ + +/*! + \enum Q3ListBox::StringComparisonMode + + This enum type is used to set the string comparison mode when + searching for an item. We'll refer to the string being searched + as the 'target' string. + + \value CaseSensitive The strings must match case sensitively. + \value ExactMatch The target and search strings must match exactly. + \value BeginsWith The target string begins with the search string. + \value EndsWith The target string ends with the search string. + \value Contains The target string contains the search string. + + If you OR these flags together (excluding \c CaseSensitive), the + search criteria be applied in the following order: \c ExactMatch, + \c BeginsWith, \c EndsWith, \c Contains. + + Matching is case-insensitive unless \c CaseSensitive is set. \c + CaseSensitive can be OR-ed with any combination of the other + flags. + + \sa ComparisonFlags +*/ + +/*! + \typedef Q3ListBox::ComparisonFlags + + This typedef is used in Q3IconView's API for values that are OR'd + combinations of \l StringComparisonMode values. + + \sa StringComparisonMode +*/ + +QT_END_NAMESPACE + +#endif // QT_NO_LISTBOX diff --git a/src/qt3support/itemviews/q3listbox.h b/src/qt3support/itemviews/q3listbox.h new file mode 100644 index 0000000..376dd65 --- /dev/null +++ b/src/qt3support/itemviews/q3listbox.h @@ -0,0 +1,429 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3LISTBOX_H +#define Q3LISTBOX_H + +#include <Qt3Support/q3scrollview.h> +#include <QtGui/qpixmap.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_LISTBOX + +class Q3ListBoxPrivate; +class Q3ListBoxItem; +class QString; +class QStringList; + +class Q_COMPAT_EXPORT Q3ListBox : public Q3ScrollView +{ + friend class Q3ListBoxItem; + friend class Q3ListBoxPrivate; + + Q_OBJECT + Q_ENUMS(SelectionMode LayoutMode) + Q_PROPERTY(uint count READ count) + Q_PROPERTY(int numItemsVisible READ numItemsVisible) + Q_PROPERTY(int currentItem READ currentItem WRITE setCurrentItem USER true) + Q_PROPERTY(QString currentText READ currentText) + Q_PROPERTY(int topItem READ topItem WRITE setTopItem DESIGNABLE false) + Q_PROPERTY(SelectionMode selectionMode READ selectionMode WRITE setSelectionMode) + Q_PROPERTY(bool multiSelection READ isMultiSelection WRITE setMultiSelection DESIGNABLE false) + Q_PROPERTY(LayoutMode columnMode READ columnMode WRITE setColumnMode) + Q_PROPERTY(LayoutMode rowMode READ rowMode WRITE setRowMode) + Q_PROPERTY(int numColumns READ numColumns) + Q_PROPERTY(int numRows READ numRows) + Q_PROPERTY(bool variableWidth READ variableWidth WRITE setVariableWidth) + Q_PROPERTY(bool variableHeight READ variableHeight WRITE setVariableHeight) + +public: + Q3ListBox(QWidget* parent=0, const char* name=0, Qt::WindowFlags f=0 ); + ~Q3ListBox(); + + uint count() const; + + void insertStringList(const QStringList&, int index=-1); +// ### fix before Qt 4.0 +#if 0 + void insertStrList(const QStrList *, int index=-1); + void insertStrList(const QStrList &, int index=-1); +#endif + void insertStrList(const char **, + int numStrings=-1, int index=-1); + + void insertItem(const Q3ListBoxItem *, int index=-1); + void insertItem(const Q3ListBoxItem *, const Q3ListBoxItem *after); + void insertItem(const QString &text, int index=-1); + void insertItem(const QPixmap &pixmap, int index=-1); + void insertItem(const QPixmap &pixmap, const QString &text, int index=-1); + + void removeItem(int index); + + QString text(int index) const; + const QPixmap *pixmap(int index) const; + + void changeItem(const Q3ListBoxItem *, int index); + void changeItem(const QString &text, int index); + void changeItem(const QPixmap &pixmap, int index); + void changeItem(const QPixmap &pixmap, const QString &text, int index); + + void takeItem(const Q3ListBoxItem *); + + int numItemsVisible() const; + + int currentItem() const; + QString currentText() const { return text(currentItem()); } + virtual void setCurrentItem(int index); + virtual void setCurrentItem(Q3ListBoxItem *); + void centerCurrentItem() { ensureCurrentVisible(); } + int topItem() const; + virtual void setTopItem(int index); + virtual void setBottomItem(int index); + + long maxItemWidth() const; + + enum SelectionMode { Single, Multi, Extended, NoSelection }; + virtual void setSelectionMode(SelectionMode); + SelectionMode selectionMode() const; + + void setMultiSelection(bool multi); + bool isMultiSelection() const; + + QVariant inputMethodQuery(Qt::InputMethodQuery query) const; + + virtual void setSelected(Q3ListBoxItem *, bool); + void setSelected(int, bool); + bool isSelected(int) const; + bool isSelected(const Q3ListBoxItem *) const; + Q3ListBoxItem* selectedItem() const; + + QSize sizeHint() const; + QSize minimumSizeHint() const; + + Q3ListBoxItem *item(int index) const; + int index(const Q3ListBoxItem *) const; + + enum StringComparisonMode { + CaseSensitive = 0x00001, // 0 0001 + BeginsWith = 0x00002, // 0 0010 + EndsWith = 0x00004, // 0 0100 + Contains = 0x00008, // 0 1000 + ExactMatch = 0x00010 // 1 0000 + }; + typedef uint ComparisonFlags; + Q3ListBoxItem *findItem(const QString &text, ComparisonFlags compare = BeginsWith) const; + + void triggerUpdate(bool doLayout); + + bool itemVisible(int index); + bool itemVisible(const Q3ListBoxItem *); + + enum LayoutMode { FixedNumber, + FitToWidth, FitToHeight = FitToWidth, + Variable }; + virtual void setColumnMode(LayoutMode); + virtual void setColumnMode(int); + virtual void setRowMode(LayoutMode); + virtual void setRowMode(int); + + LayoutMode columnMode() const; + LayoutMode rowMode() const; + + int numColumns() const; + int numRows() const; + + bool variableWidth() const; + virtual void setVariableWidth(bool); + + bool variableHeight() const; + virtual void setVariableHeight(bool); + + void viewportPaintEvent(QPaintEvent *); + + bool dragSelect() const { return true; } + void setDragSelect(bool) {} + bool autoScroll() const { return true; } + void setAutoScroll(bool) {} + bool autoScrollBar() const { return vScrollBarMode() == Auto; } + void setAutoScrollBar(bool enable) { setVScrollBarMode(enable ? Auto : AlwaysOff); } + bool scrollBar() const { return vScrollBarMode() != AlwaysOff; } + void setScrollBar(bool enable) { setVScrollBarMode(enable ? AlwaysOn : AlwaysOff); } + bool autoBottomScrollBar() const { return hScrollBarMode() == Auto; } + void setAutoBottomScrollBar(bool enable) { setHScrollBarMode(enable ? Auto : AlwaysOff); } + bool bottomScrollBar() const { return hScrollBarMode() != AlwaysOff; } + void setBottomScrollBar(bool enable) { setHScrollBarMode(enable ? AlwaysOn : AlwaysOff); } + bool smoothScrolling() const { return false; } + void setSmoothScrolling(bool) {} + bool autoUpdate() const { return true; } + void setAutoUpdate(bool) {} + void setFixedVisibleLines(int lines) { setRowMode(lines); } + int inSort(const Q3ListBoxItem *); + int inSort(const QString& text); + int cellHeight(int i) const { return itemHeight(i); } + int cellHeight() const { return itemHeight(); } + int cellWidth() const { return maxItemWidth(); } + int cellWidth(int i) const { Q_ASSERT(i==0); Q_UNUSED(i) return maxItemWidth(); } + int numCols() const { return numColumns(); } + + int itemHeight(int index = 0) const; + Q3ListBoxItem * itemAt(const QPoint &) const; + + QRect itemRect(Q3ListBoxItem *item) const; + + Q3ListBoxItem *firstItem() const; + + void sort(bool ascending = true); + +public Q_SLOTS: + void clear(); + virtual void ensureCurrentVisible(); + virtual void clearSelection(); + virtual void selectAll(bool select); + virtual void invertSelection(); + +Q_SIGNALS: + void highlighted(int index); + void selected(int index); + void highlighted(const QString &); + void selected(const QString &); + void highlighted(Q3ListBoxItem *); + void selected(Q3ListBoxItem *); + + void selectionChanged(); + void selectionChanged(Q3ListBoxItem *); + void currentChanged(Q3ListBoxItem *); + void clicked(Q3ListBoxItem *); + void clicked(Q3ListBoxItem *, const QPoint &); + void pressed(Q3ListBoxItem *); + void pressed(Q3ListBoxItem *, const QPoint &); + + void doubleClicked(Q3ListBoxItem *); + void returnPressed(Q3ListBoxItem *); + void rightButtonClicked(Q3ListBoxItem *, const QPoint &); + void rightButtonPressed(Q3ListBoxItem *, const QPoint &); + void mouseButtonPressed(int, Q3ListBoxItem*, const QPoint&); + void mouseButtonClicked(int, Q3ListBoxItem*, const QPoint&); + + void contextMenuRequested(Q3ListBoxItem *, const QPoint &); + + void onItem(Q3ListBoxItem *item); + void onViewport(); + +protected: + void changeEvent(QEvent *); + void mousePressEvent(QMouseEvent *); + void mouseReleaseEvent(QMouseEvent *); + void mouseDoubleClickEvent(QMouseEvent *); + void mouseMoveEvent(QMouseEvent *); + void contentsContextMenuEvent(QContextMenuEvent *); + + void keyPressEvent(QKeyEvent *e); + void focusInEvent(QFocusEvent *e); + void focusOutEvent(QFocusEvent *e); + void resizeEvent(QResizeEvent *); + void showEvent(QShowEvent *); + + bool eventFilter(QObject *o, QEvent *e); + + void updateItem(int index); + void updateItem(Q3ListBoxItem *); + + void updateCellWidth() { } + int totalWidth() const { return contentsWidth(); } + int totalHeight() const { return contentsHeight(); } + + virtual void paintCell(QPainter *, int row, int col); + + void toggleCurrentItem(); + bool isRubberSelecting() const; + + void doLayout() const; + + int findItem(int yPos) const { return index(itemAt(QPoint(0,yPos))); } + +protected Q_SLOTS: + void clearInputString(); + +private Q_SLOTS: + void refreshSlot(); + void doAutoScroll(); + void adjustItems(); + +private: + Q_DISABLE_COPY(Q3ListBox) + + void mousePressEventEx(QMouseEvent *); + void tryGeometry(int, int) const; + int currentRow() const; + int currentColumn() const; + void updateSelection(); + void repaintSelection(); + void drawRubber(); + void doRubberSelection(const QRect &old, const QRect &rubber); + void handleItemChange(Q3ListBoxItem *old, bool shift, bool control); + void selectRange(Q3ListBoxItem *from, Q3ListBoxItem *to, bool invert, bool includeFirst, bool clearSel = false); + + void emitChangedSignal(bool); + + int columnAt(int) const; + int rowAt(int) const; + + Q3ListBoxPrivate * d; + + static Q3ListBox * changedListBox; +}; + + +class Q_COMPAT_EXPORT Q3ListBoxItem +{ +public: + Q3ListBoxItem(Q3ListBox* listbox = 0); + Q3ListBoxItem(Q3ListBox* listbox, Q3ListBoxItem *after); + virtual ~Q3ListBoxItem(); + + virtual QString text() const; + virtual const QPixmap *pixmap() const; + + virtual int height(const Q3ListBox *) const; + virtual int width(const Q3ListBox *) const; + + bool isSelected() const { return s; } + bool isCurrent() const; + + bool selected() const { return isSelected(); } + bool current() const { return isCurrent(); } + + Q3ListBox *listBox() const; + + void setSelectable(bool b) { selectable = b; } + bool isSelectable() const { return selectable; } + + Q3ListBoxItem *next() const; + Q3ListBoxItem *prev() const; + + virtual int rtti() const; + enum { RTTI = 0 }; + +protected: + virtual void paint(QPainter *) = 0; + virtual void setText(const QString &text) { txt = text; } + void setCustomHighlighting(bool); + +private: + Q_DISABLE_COPY(Q3ListBoxItem) + + QString txt; + uint selectable : 1; + uint s : 1; + uint dirty:1; + uint custom_highlight : 1; + uint unused : 28; + Q3ListBoxItem * p, * n; + Q3ListBox* lbox; + friend class Q3ListBox; + friend class Q3ListBoxPrivate; + friend class Q3ComboBox; + friend class Q3ComboBoxPopupItem; +}; + + +class Q_COMPAT_EXPORT Q3ListBoxText : public Q3ListBoxItem +{ +public: + Q3ListBoxText(Q3ListBox* listbox, const QString & text=QString()); + Q3ListBoxText(const QString & text=QString()); + Q3ListBoxText(Q3ListBox* listbox, const QString & text, Q3ListBoxItem *after); + ~Q3ListBoxText(); + + int height(const Q3ListBox *) const; + int width(const Q3ListBox *) const; + + int rtti() const; + enum { RTTI = 1 }; + +protected: + void paint(QPainter *); + +private: + Q_DISABLE_COPY(Q3ListBoxText) +}; + + +class Q_COMPAT_EXPORT Q3ListBoxPixmap : public Q3ListBoxItem +{ +public: + Q3ListBoxPixmap(Q3ListBox* listbox, const QPixmap &); + Q3ListBoxPixmap(const QPixmap &); + Q3ListBoxPixmap(Q3ListBox* listbox, const QPixmap & pix, Q3ListBoxItem *after); + Q3ListBoxPixmap(Q3ListBox* listbox, const QPixmap &, const QString&); + Q3ListBoxPixmap(const QPixmap &, const QString&); + Q3ListBoxPixmap(Q3ListBox* listbox, const QPixmap & pix, const QString&, Q3ListBoxItem *after); + ~Q3ListBoxPixmap(); + + const QPixmap *pixmap() const { return ± } + + int height(const Q3ListBox *) const; + int width(const Q3ListBox *) const; + + int rtti() const; + enum { RTTI = 2 }; + +protected: + void paint(QPainter *); + +private: + Q_DISABLE_COPY(Q3ListBoxPixmap) + + QPixmap pm; +}; + +#endif // QT_NO_LISTBOX + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3LISTBOX_H diff --git a/src/qt3support/itemviews/q3listview.cpp b/src/qt3support/itemviews/q3listview.cpp new file mode 100644 index 0000000..1effdaa --- /dev/null +++ b/src/qt3support/itemviews/q3listview.cpp @@ -0,0 +1,7949 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <qplatformdefs.h> +#include "q3listview.h" +#ifndef QT_NO_LISTVIEW +#include "q3tl.h" +#include "qapplication.h" +#include "qbitmap.h" +#include "q3cleanuphandler.h" +#include "qcursor.h" +#include "qdatetime.h" +#include "q3dragobject.h" +#include "qevent.h" +#include "qhash.h" +#include "q3header.h" +#include "qicon.h" +#include "qlineedit.h" +#include "qpainter.h" +#include "qpixmapcache.h" +#include "qstack.h" +#include "qstyle.h" +#include "qstyleoption.h" +#include "qtimer.h" +#include "qtooltip.h" +#include "qdebug.h" +#ifndef QT_NO_ACCESSIBILITY +#include "qaccessible.h" +#endif + +QT_BEGIN_NAMESPACE + +const int Unsorted = 16383; + +static Q3CleanupHandler<QBitmap> qlv_cleanup_bitmap; + + +struct Q3ListViewPrivate +{ + // classes that are here to avoid polluting the global name space + + // the magical hidden mother of all items + class Root: public Q3ListViewItem { + public: + Root(Q3ListView * parent); + + void setHeight(int); + void invalidateHeight(); + void setup(); + Q3ListView * theListView() const; + + Q3ListView * lv; + }; + + // to remember what's on screen + class DrawableItem { + public: + DrawableItem() {} + DrawableItem(int level, int ypos, Q3ListViewItem * item) + : l(level), y(ypos), i(item) {}; + int l; + int y; + Q3ListViewItem * i; + }; + + // for sorting + class SortableItem { + public: + /* + We could be smarter and keep a pointer to the Q3ListView + item instead of numCols, col and asc. This would then allow + us to use the physical ordering of columns rather than the + logical. Microsoft uses the logical ordering, so there is + some virtue in doing so, although it prevents the user from + choosing the secondary key. + */ + Q3ListViewItem * item; + int numCols; + int col; + bool asc; + + int cmp(const SortableItem& i) const { + int diff = item->compare(i.item, col, asc); + if (diff == 0 && numCols != 1) { + for (int j = 0; j < numCols; j++) { + if (j != col) { + diff = item->compare(i.item, j, asc); + if (diff != 0) + break; + } + } + } + return diff; + } + bool operator<(const SortableItem& i) const { return cmp(i) < 0; } + bool operator<=(const SortableItem& i) const { return cmp(i) <= 0; } + bool operator>(const SortableItem& i) const { return cmp(i) > 0; } + }; + + class ItemColumnInfo { + public: + ItemColumnInfo(): pm(0), next(0), truncated(false), dirty(false), allow_rename(false), width(0) {} + ~ItemColumnInfo() { delete pm; delete next; } + QString text, tmpText; + QPixmap * pm; + ItemColumnInfo * next; + uint truncated : 1; + uint dirty : 1; + uint allow_rename : 1; + int width; + }; + + class ViewColumnInfo { + public: + ViewColumnInfo(): align(Qt::AlignAuto), sortable(true), next(0) {} + ~ViewColumnInfo() { delete next; } + int align; + bool sortable; + ViewColumnInfo * next; + }; + + // private variables used in Q3ListView + ViewColumnInfo * vci; + Q3Header * h; + Root * r; + uint rootIsExpandable : 1; + int margin; + + Q3ListViewItem * focusItem, *highlighted, *oldFocusItem; + + QTimer * timer; + QTimer * dirtyItemTimer; + QTimer * visibleTimer; + int levelWidth; + + // the list of drawables, and the range drawables covers entirely + // (it may also include a few items above topPixel) + QList<DrawableItem> drawables; + int topPixel; + int bottomPixel; + + QList<const Q3ListViewItem *> dirtyItems; + + Q3ListView::SelectionMode selectionMode; + + // Per-column structure for information not in the Q3Header + struct Column { + Q3ListView::WidthMode wmode; + }; + QVector<Column> column; + + // suggested height for the items + int fontMetricsHeight; + int minLeftBearing, minRightBearing; + int ellipsisWidth; + + // currently typed prefix for the keyboard interface, and the time + // of the last key-press + QString currentPrefix; + QTime currentPrefixTime; + + // holds a list of iterators + QList<Q3ListViewItemIterator *> iterators; + Q3ListViewItem *pressedItem, *selectAnchor; + + QTimer *scrollTimer; + QTimer *renameTimer; + QTimer *autoopenTimer; + + // sort column and order #### may need to move to Q3Header [subclass] + int sortcolumn; + bool ascending :1; + bool sortIndicator :1; + // whether to select or deselect during this mouse press. + bool allColumnsShowFocus :1; + bool select :1; + + // true if the widget should take notice of mouseReleaseEvent + bool buttonDown :1; + // true if the widget should ignore a double-click + bool ignoreDoubleClick :1; + + bool clearing :1; + bool pressedSelected :1; + bool pressedEmptyArea :1; + + bool toolTips :1; + bool fullRepaintOnComlumnChange:1; + bool updateHeader :1; + + bool startEdit : 1; + bool ignoreEditAfterFocus : 1; + bool inMenuMode :1; + + Q3ListView::RenameAction defRenameAction; + + Q3ListViewItem *startDragItem; + QPoint dragStartPos; + int pressedColumn; + Q3ListView::ResizeMode resizeMode; +}; + +Q_DECLARE_TYPEINFO(Q3ListViewPrivate::DrawableItem, Q_PRIMITIVE_TYPE); + +// these should probably be in Q3ListViewPrivate, for future thread safety +static bool activatedByClick; +static QPoint activatedP; + +#ifndef QT_NO_ACCESSIBILITY +static int indexOfItem(Q3ListViewItem *item) +{ + if (!QAccessible::isActive()) + return 0; + + static Q3ListViewItem *lastItem = 0; + static int lastIndex = 0; + + if (!item || !item->listView()) + return 0; + + if (item == lastItem) + return lastIndex; + + lastItem = item; + int index = 1; + + Q3ListViewItemIterator it(item->listView()); + while (it.current()) { + if (it.current() == item) { + lastIndex = index; + return index; + } + ++it; + ++index; + } + lastIndex = 0; + return 0; +} +#endif + +/*! + Creates a string with ... like "Trollte..." or "...olltech", depending on the alignment. +*/ +static QString qEllipsisText(const QString &org, const QFontMetrics &fm, int width, int align) +{ + int ellWidth = fm.width(QLatin1String("...")); + QString text = QString::fromLatin1(""); + int i = 0; + int len = org.length(); + int offset = (align & Qt::AlignRight) ? (len-1) - i : i; + while (i < len && fm.width(text + org[offset]) + ellWidth < width) { + if (align & Qt::AlignRight) + text.prepend(org[offset]); + else + text += org[offset]; + offset = (align & Qt::AlignRight) ? (len-1) - ++i : ++i; + } + if (text.isEmpty()) + text = (align & Qt::AlignRight) ? org.right(1) : text = org.left(1); + if (align & Qt::AlignRight) + text.prepend(QLatin1String("...")); + else + text += QLatin1String("..."); + return text; +} + +/*! + \class Q3ListViewItem + \brief The Q3ListViewItem class implements a list view item. + + \compat + + A list view item is a multi-column object capable of displaying + itself in a Q3ListView. + + The easiest way to use Q3ListViewItem is to construct one with a + few constant strings, and either a Q3ListView or another + Q3ListViewItem as parent. + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 0 + We've discarded the pointers to the items since we can still access + them via their parent \e listView. By default, Q3ListView sorts its + items; this can be switched off with Q3ListView::setSorting(-1). + + The parent must be another Q3ListViewItem or a Q3ListView. If the + parent is a Q3ListView, the item becomes a top-level item within + that Q3ListView. If the parent is another Q3ListViewItem, the item + becomes a child of that list view item. + + If you keep the pointer, you can set or change the texts using + setText(), add pixmaps using setPixmap(), change its mode using + setSelectable(), setSelected(), setOpen() and setExpandable(). + You'll also be able to change its height using setHeight(), and + traverse its sub-items. You don't have to keep the pointer since + you can get a pointer to any Q3ListViewItem in a Q3ListView using + Q3ListView::selectedItem(), Q3ListView::currentItem(), + Q3ListView::firstChild(), Q3ListView::lastItem() and + Q3ListView::findItem(). + + If you call \c delete on a list view item, it will be deleted as + expected, and as usual for \l{QObject}s, if it has any child items + (to any depth), all these will be deleted too. + + \l{Q3CheckListItem}s are list view items that have a checkbox or + radio button and can be used in place of plain Q3ListViewItems. + + You can traverse the tree as if it were a doubly-linked list using + itemAbove() and itemBelow(); they return pointers to the items + directly above and below this item on the screen (even if none of + them are actually visible at the moment). + + Here's how to traverse all of an item's children (but not its + children's children, etc.): + Example: + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 1 + + If you want to iterate over every item, to any level of depth use + an iterator. To iterate over the entire tree, initialize the + iterator with the list view itself; to iterate over an item's + children (and children's children to any depth), initialize the + iterator with the item: + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 2 + + Note that the order of the children will change when the sorting + order changes and is undefined if the items are not visible. You + can, however, call enforceSortOrder() at any time; Q3ListView will + always call it before it needs to show an item. + + Many programs will need to reimplement Q3ListViewItem. The most + commonly reimplemented functions are: + \table + \header \i Function \i Description + \row \i \l text() + \i Returns the text in a column. Many subclasses will compute + this on the fly. + \row \i \l key() + \i Used for sorting. The default key() simply calls + text(), but judicious use of key() can give you fine + control over sorting; for example, QFileDialog + reimplements key() to sort by date. + \row \i \l setup() + \i Called before showing the item and whenever the list + view's font changes, for example. + \row \i \l activate() + \i Called whenever the user clicks on the item or presses + Space when the item is the current item. + \endtable + + Some subclasses call setExpandable(true) even when they have no + children, and populate themselves when setup() or setOpen(true) is + called. The \c dirview/dirview.cpp example program uses this + technique to start up quickly: The files and subdirectories in a + directory aren't inserted into the tree until they're actually + needed. + + \img qlistviewitems.png List View Items + + \sa Q3CheckListItem Q3ListView +*/ + +/*! + \fn int Q3CheckListItem::rtti() const + + Returns 1. + + Make your derived classes return their own values for rtti(), and + you can distinguish between list view items. You should use values + greater than 1000, to allow for extensions to this class. +*/ + +/*! + Constructs a new top-level list view item in the Q3ListView \a + parent. +*/ + +Q3ListViewItem::Q3ListViewItem(Q3ListView * parent) +{ + init(); + parent->insertItem(this); +} + + +/*! + Constructs a new list view item that is a child of \a parent and + first in the parent's list of children. +*/ + +Q3ListViewItem::Q3ListViewItem(Q3ListViewItem * parent) +{ + init(); + parent->insertItem(this); +} + + + + +/*! + Constructs an empty list view item that is a child of \a parent + and is after item \a after in the parent's list of children. Since + \a parent is a Q3ListView the item will be a top-level item. +*/ + +Q3ListViewItem::Q3ListViewItem(Q3ListView * parent, Q3ListViewItem * after) +{ + init(); + parent->insertItem(this); + moveToJustAfter(after); +} + + +/*! + Constructs an empty list view item that is a child of \a parent + and is after item \a after in the parent's list of children. +*/ + +Q3ListViewItem::Q3ListViewItem(Q3ListViewItem * parent, Q3ListViewItem * after) +{ + init(); + parent->insertItem(this); + moveToJustAfter(after); +} + + + +/*! + Constructs a new top-level list view item in the Q3ListView \a + parent, with up to eight constant strings, \a label1, \a label2, \a + label3, \a label4, \a label5, \a label6, \a label7 and \a label8 + defining its columns' contents. + + \sa setText() +*/ + +Q3ListViewItem::Q3ListViewItem(Q3ListView * parent, + const QString &label1, + const QString &label2, + const QString &label3, + const QString &label4, + const QString &label5, + const QString &label6, + const QString &label7, + const QString &label8) +{ + init(); + parent->insertItem(this); + + setText(0, label1); + setText(1, label2); + setText(2, label3); + setText(3, label4); + setText(4, label5); + setText(5, label6); + setText(6, label7); + setText(7, label8); +} + + +/*! + Constructs a new list view item as a child of the Q3ListViewItem \a + parent with up to eight constant strings, \a label1, \a label2, \a + label3, \a label4, \a label5, \a label6, \a label7 and \a label8 + as columns' contents. + + \sa setText() +*/ + +Q3ListViewItem::Q3ListViewItem(Q3ListViewItem * parent, + const QString &label1, + const QString &label2, + const QString &label3, + const QString &label4, + const QString &label5, + const QString &label6, + const QString &label7, + const QString &label8) +{ + init(); + parent->insertItem(this); + + setText(0, label1); + setText(1, label2); + setText(2, label3); + setText(3, label4); + setText(4, label5); + setText(5, label6); + setText(6, label7); + setText(7, label8); +} + +/*! + Constructs a new list view item in the Q3ListView \a parent that is + included after item \a after and that has up to eight column + texts, \a label1, \a label2, \a label3, \a label4, \a label5, \a + label6, \a label7 and\a label8. + + Note that the order is changed according to Q3ListViewItem::key() + unless the list view's sorting is disabled using + Q3ListView::setSorting(-1). + + \sa setText() +*/ + +Q3ListViewItem::Q3ListViewItem(Q3ListView * parent, Q3ListViewItem * after, + const QString &label1, + const QString &label2, + const QString &label3, + const QString &label4, + const QString &label5, + const QString &label6, + const QString &label7, + const QString &label8) +{ + init(); + parent->insertItem(this); + moveToJustAfter(after); + + setText(0, label1); + setText(1, label2); + setText(2, label3); + setText(3, label4); + setText(4, label5); + setText(5, label6); + setText(6, label7); + setText(7, label8); +} + + +/*! + Constructs a new list view item as a child of the Q3ListViewItem \a + parent. It is inserted after item \a after and may contain up to + eight strings, \a label1, \a label2, \a label3, \a label4, \a + label5, \a label6, \a label7 and \a label8 as column entries. + + Note that the order is changed according to Q3ListViewItem::key() + unless the list view's sorting is disabled using + Q3ListView::setSorting(-1). + + \sa setText() +*/ + +Q3ListViewItem::Q3ListViewItem(Q3ListViewItem * parent, Q3ListViewItem * after, + const QString &label1, + const QString &label2, + const QString &label3, + const QString &label4, + const QString &label5, + const QString &label6, + const QString &label7, + const QString &label8) +{ + init(); + parent->insertItem(this); + moveToJustAfter(after); + + setText(0, label1); + setText(1, label2); + setText(2, label3); + setText(3, label4); + setText(4, label5); + setText(5, label6); + setText(6, label7); + setText(7, label8); +} + +/*! + Sorts all this item's child items using the current sorting + configuration (sort column and direction). + + \sa enforceSortOrder() +*/ + +void Q3ListViewItem::sort() +{ + if (!listView()) + return; + lsc = Unsorted; + enforceSortOrder(); + listView()->triggerUpdate(); +} + +/*! + Returns 0. + + Make your derived classes return their own values for rtti(), so + that you can distinguish between different kinds of list view + items. You should use values greater than 1000 to allow for + extensions to this class. +*/ + +int Q3ListViewItem::rtti() const +{ + return RTTI; +} + +/* + Performs the initializations that's common to the constructors. +*/ + +void Q3ListViewItem::init() +{ + ownHeight = 0; + maybeTotalHeight = -1; + open = false; + + nChildren = 0; + parentItem = 0; + siblingItem = childItem = 0; + + columns = 0; + + selected = 0; + selectable = true; + + lsc = Unsorted; + lso = true; // unsorted in ascending order :) + configured = false; + expandable = false; + selectable = true; + is_root = false; + allow_drag = false; + allow_drop = false; + visible = true; + renameBox = 0; + enabled = true; + mlenabled = false; +} + +/*! + If \a b is true, the item is made visible; otherwise it is hidden. + + If the item is not visible, itemAbove() and itemBelow() will never + return this item, although you still can reach it by using e.g. + Q3ListViewItemIterator. +*/ + +void Q3ListViewItem::setVisible(bool b) +{ + if (b == (bool)visible) + return; + Q3ListView *lv = listView(); + if (!lv) + return; + if (b && parent() && !parent()->isVisible()) + return; + visible = b; + configured = false; + setHeight(0); + invalidateHeight(); + if (parent()) + parent()->invalidateHeight(); + else + lv->d->r->invalidateHeight(); + for (Q3ListViewItem *i = childItem; i; i = i->siblingItem) + i->setVisible(b); + if (lv) + lv->triggerUpdate(); +} + +/*! + Returns true if the item is visible; otherwise returns false. + + \sa setVisible() +*/ + +bool Q3ListViewItem::isVisible() const +{ + return (bool)visible; +} + +/*! + If \a b is true, this item can be in-place renamed in the column + \a col by the user; otherwise it cannot be renamed in-place. +*/ + +void Q3ListViewItem::setRenameEnabled(int col, bool b) +{ + Q3ListViewPrivate::ItemColumnInfo * l = (Q3ListViewPrivate::ItemColumnInfo*)columns; + if (!l) { + l = new Q3ListViewPrivate::ItemColumnInfo; + columns = (void*)l; + } + for(int c = 0; c < col; c++) { + if (!l->next) + l->next = new Q3ListViewPrivate::ItemColumnInfo; + l = l->next; + } + + if (!l) + return; + l->allow_rename = b; +} + +/*! + Returns true if this item can be in-place renamed in column \a + col; otherwise returns false. +*/ + +bool Q3ListViewItem::renameEnabled(int col) const +{ + Q3ListViewPrivate::ItemColumnInfo * l = (Q3ListViewPrivate::ItemColumnInfo*)columns; + if (!l) + return false; + + while(col && l) { + l = l->next; + col--; + } + + if (!l) + return false; + return (bool)l->allow_rename; +} + +/*! + If \a b is true the item is enabled; otherwise it is disabled. + Disabled items are drawn differently (e.g. grayed-out) and are not + accessible by the user. +*/ + +void Q3ListViewItem::setEnabled(bool b) +{ + if ((bool)enabled == b) + return; + enabled = b; + if (!enabled) + selected = false; + Q3ListView *lv = listView(); + if (lv) { + lv->triggerUpdate(); + +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(lv->viewport(), indexOfItem(this), QAccessible::StateChanged); +#endif + } +} + +/*! + Returns true if this item is enabled; otherwise returns false. + + \sa setEnabled() +*/ + +bool Q3ListViewItem::isEnabled() const +{ + return (bool)enabled; +} + +/*! + If in-place renaming of this item is enabled (see + renameEnabled()), this function starts renaming the item in column + \a col, by creating and initializing an edit box. +*/ + +void Q3ListViewItem::startRename(int col) +{ + if (!renameEnabled(col)) + return; + if (renameBox) + cancelRename(col); + Q3ListView *lv = listView(); + if (!lv) + return; + + if (lv->d->renameTimer) + lv->d->renameTimer->stop(); + + lv->ensureItemVisible(this); + + if (lv->d->timer->isActive()) { + // make sure that pending calculations get finished + lv->d->timer->stop(); + lv->updateContents(); + } + + if (lv->currentItem() && lv->currentItem()->renameBox) { + if (lv->d->defRenameAction == Q3ListView::Reject) + lv->currentItem()->cancelRename(lv->currentItem()->renameCol); + else + lv->currentItem()->okRename(lv->currentItem()->renameCol); + } + + if (this != lv->currentItem()) + lv->setCurrentItem(this); + + QRect r = lv->itemRect(this); + r = QRect(lv->viewportToContents(r.topLeft()), r.size()); + r.setLeft(lv->header()->sectionPos(col)); + r.setWidth(qMin(lv->header()->sectionSize(col) - 1, + lv->contentsX() + lv->visibleWidth() - r.left())); + if (col == 0) + r.setLeft(r.left() + lv->itemMargin() + (depth() + (lv->rootIsDecorated() ? 1 : 0)) * lv->treeStepSize() - 1); + if (pixmap(col)) + r.setLeft(r.left() + pixmap(col)->width()); + if (r.x() - lv->contentsX() < 0) { + lv->scrollBy(r.x() - lv->contentsX(), 0); + r.setX(lv->contentsX()); + } else if ((lv->contentsX() + lv->visibleWidth()) < (r.x() + r.width())) { + lv->scrollBy((r.x() + r.width()) - (lv->contentsX() + lv->visibleWidth()), 0); + } + if (r.width() > lv->visibleWidth()) + r.setWidth(lv->visibleWidth()); + renameBox = new QLineEdit(lv->viewport(), "qt_renamebox"); + renameBox->setFrame(false); + renameBox->setText(text(col)); + renameBox->selectAll(); + renameBox->installEventFilter(lv); + lv->addChild(renameBox, r.x(), r.y()); + renameBox->resize(r.size()); + lv->viewport()->setFocusProxy(renameBox); + renameBox->setFocus(); + renameBox->show(); + renameCol = col; +} + +/*! + This function removes the rename box. +*/ + +void Q3ListViewItem::removeRenameBox() +{ + // Sanity, it should be checked by the functions calling this first anyway + Q3ListView *lv = listView(); + if (!lv || !renameBox) + return; + const bool resetFocus = lv->viewport()->focusProxy() == renameBox; + delete renameBox; + renameBox = 0; + if (resetFocus) { + lv->viewport()->setFocusProxy(lv); + lv->setFocus(); + } +} + +/*! + This function is called if the user presses Enter during in-place + renaming of the item in column \a col. + + \sa cancelRename() +*/ + +void Q3ListViewItem::okRename(int col) +{ + Q3ListView *lv = listView(); + if (!lv || !renameBox) + return; + setText(col, renameBox->text()); + removeRenameBox(); + + // we set the parent lsc to Unsorted if that column is the sorted one + if (parent() && (int)parent()->lsc == col) + parent()->lsc = Unsorted; + + emit lv->itemRenamed(this, col); + emit lv->itemRenamed(this, col, text(col)); +} + +/*! + This function is called if the user cancels in-place renaming of + this item in column \a col (e.g. by pressing Esc). + + \sa okRename() +*/ + +void Q3ListViewItem::cancelRename(int) +{ + Q3ListView *lv = listView(); + if (!lv || !renameBox) + return; + removeRenameBox(); +} + +/*! + Destroys the item, deleting all its children and freeing up all + allocated resources. +*/ + +Q3ListViewItem::~Q3ListViewItem() +{ + if (renameBox) { + delete renameBox; + renameBox = 0; + } + + Q3ListView *lv = listView(); + + if (lv) { + if (lv->d->oldFocusItem == this) + lv->d->oldFocusItem = 0; + if (lv->d->focusItem == this) + lv->d->focusItem = 0; + if (lv->d->highlighted == this) + lv->d->highlighted = 0; + if (lv->d->pressedItem == this) + lv->d->pressedItem = 0; + if (lv->d->selectAnchor == this) + lv->d->selectAnchor = 0; + for (int j = 0; j < lv->d->iterators.size(); ++j) { + Q3ListViewItemIterator *i = lv->d->iterators.at(j); + if (i->current() == this) + i->currentRemoved(); + } + } + + if (parentItem) + parentItem->takeItem(this); + Q3ListViewItem * i = childItem; + childItem = 0; + while (i) { + i->parentItem = 0; + Q3ListViewItem * n = i->siblingItem; + delete i; + i = n; + } + delete (Q3ListViewPrivate::ItemColumnInfo *)columns; +} + + +/*! + If \a b is true each of the item's columns may contain multiple + lines of text; otherwise each of them may only contain a single + line. +*/ + +void Q3ListViewItem::setMultiLinesEnabled(bool b) +{ + mlenabled = b; +} + +/*! + Returns true if the item can display multiple lines of text in its + columns; otherwise returns false. +*/ + +bool Q3ListViewItem::multiLinesEnabled() const +{ + return mlenabled; +} + +/*! + If \a allow is true, the list view starts a drag (see + Q3ListView::dragObject()) when the user presses and moves the mouse + on this item. +*/ + + +void Q3ListViewItem::setDragEnabled(bool allow) +{ + allow_drag = (uint)allow; +} + +/*! + If \a allow is true, the list view accepts drops onto the item; + otherwise drops are not allowed. +*/ + +void Q3ListViewItem::setDropEnabled(bool allow) +{ + allow_drop = (uint)allow; +} + +/*! + Returns true if this item can be dragged; otherwise returns false. + + \sa setDragEnabled() +*/ + +bool Q3ListViewItem::dragEnabled() const +{ + return (bool)allow_drag; +} + +/*! + Returns true if this item accepts drops; otherwise returns false. + + \sa setDropEnabled(), acceptDrop() +*/ + +bool Q3ListViewItem::dropEnabled() const +{ + return (bool)allow_drop; +} + +/*! + Returns true if the item can accept drops of type QMimeSource \a + mime; otherwise returns false. + + The default implementation does nothing and returns false. A + subclass must reimplement this to accept drops. +*/ + +bool Q3ListViewItem::acceptDrop(const QMimeSource *) const +{ + return false; +} + +#ifndef QT_NO_DRAGANDDROP + +/*! + This function is called when something was dropped on the item. \a e + contains all the information about the drop. + + The default implementation does nothing, subclasses may need to + reimplement this function. +*/ + +void Q3ListViewItem::dropped(QDropEvent *e) +{ + Q_UNUSED(e); +} + +#endif + +/*! + This function is called when a drag enters the item's bounding + rectangle. + + The default implementation does nothing, subclasses may need to + reimplement this function. +*/ + +void Q3ListViewItem::dragEntered() +{ +} + +/*! + This function is called when a drag leaves the item's bounding + rectangle. + + The default implementation does nothing, subclasses may need to + reimplement this function. +*/ + +void Q3ListViewItem::dragLeft() +{ +} + +/*! + Inserts \a newChild into this list view item's list of children. + You should not need to call this function; it is called + automatically by the constructor of \a newChild. + + \warning If you are using \c Single selection mode, then you + should only insert unselected items. +*/ + +void Q3ListViewItem::insertItem(Q3ListViewItem * newChild) +{ + Q3ListView *lv = listView(); + if (lv && lv->currentItem() && lv->currentItem()->renameBox) { + if (lv->d->defRenameAction == Q3ListView::Reject) + lv->currentItem()->cancelRename(lv->currentItem()->renameCol); + else + lv->currentItem()->okRename(lv->currentItem()->renameCol); + } + + if (!newChild || newChild->parentItem == this) + return; + if (newChild->parentItem) + newChild->parentItem->takeItem(newChild); + if (open) + invalidateHeight(); + newChild->siblingItem = childItem; + childItem = newChild; + nChildren++; + newChild->parentItem = this; + lsc = Unsorted; + newChild->ownHeight = 0; + newChild->configured = false; + + if (lv && !lv->d->focusItem) { + lv->d->focusItem = lv->firstChild(); + lv->d->selectAnchor = lv->d->focusItem; + lv->repaintItem(lv->d->focusItem); + } +} + + +/*! + \fn void Q3ListViewItem::removeItem(Q3ListViewItem *item) + + Removes the given \a item. Use takeItem() instead. +*/ + + +/*! + Removes \a item from this object's list of children and causes an + update of the screen display. The item is not deleted. You should + not normally need to call this function because + Q3ListViewItem::~Q3ListViewItem() calls it. + + The normal way to delete an item is to use \c delete. + + If you need to move an item from one place in the hierarchy to + another you can use takeItem() to remove the item from the list + view and then insertItem() to put the item back in its new + position. + + If a taken item is part of a selection in \c Single selection + mode, it is unselected and selectionChanged() is emitted. If a + taken item is part of a selection in \c Multi or \c Extended + selection mode, it remains selected. + + \warning This function leaves \a item and its children in a state + where most member functions are unsafe. Only a few functions work + correctly on an item in this state, most notably insertItem(). The + functions that work on taken items are explicitly documented as + such. + + \sa Q3ListViewItem::insertItem() +*/ + +void Q3ListViewItem::takeItem(Q3ListViewItem * item) +{ + if (!item) + return; + + Q3ListView *lv = listView(); + if (lv && lv->currentItem() && lv->currentItem()->renameBox) { + if (lv->d->defRenameAction == Q3ListView::Reject) + lv->currentItem()->cancelRename(lv->currentItem()->renameCol); + else + lv->currentItem()->okRename(lv->currentItem()->renameCol); + } + bool emit_changed = false; + if (lv && !lv->d->clearing) { + if (lv->d->oldFocusItem == this) + lv->d->oldFocusItem = 0; + + for (int j = 0; j < lv->d->iterators.size(); ++j) { + Q3ListViewItemIterator *i = lv->d->iterators.at(j); + if (i->current() == item) + i->currentRemoved(); + } + + invalidateHeight(); + + if (lv->d && !lv->d->drawables.isEmpty()) + lv->d->drawables.clear(); + + if (!lv->d->dirtyItems.isEmpty()) { + if (item->childItem) { + lv->d->dirtyItems.clear(); + lv->d->dirtyItemTimer->stop(); + lv->triggerUpdate(); + } else { + lv->d->dirtyItems.removeAll(item); + } + } + + if (lv->d->focusItem) { + const Q3ListViewItem * c = lv->d->focusItem; + while(c && c != item) + c = c->parentItem; + if (c == item) { + if (lv->selectedItem()) { + // for Single, setSelected(false) when selectedItem() is taken + lv->selectedItem()->setSelected(false); + // we don't emit selectionChanged(0) + emit lv->selectionChanged(); + } + if (item->nextSibling()) + lv->d->focusItem = item->nextSibling(); + else if (item->itemAbove()) + lv->d->focusItem = item->itemAbove(); + else + lv->d->focusItem = 0; + emit_changed = true; + } + } + + // reset anchors etc. if they are set to this or any child + // items + const Q3ListViewItem *ptr = lv->d->selectAnchor; + while (ptr && ptr != item) + ptr = ptr->parentItem; + if (ptr == item) + lv->d->selectAnchor = lv->d->focusItem; + + ptr = lv->d->startDragItem; + while (ptr && ptr != item) + ptr = ptr->parentItem; + if (ptr == item) + lv->d->startDragItem = 0; + + ptr = lv->d->pressedItem; + while (ptr && ptr != item) + ptr = ptr->parentItem; + if (ptr == item) + lv->d->pressedItem = 0; + + ptr = lv->d->highlighted; + while (ptr && ptr != item) + ptr = ptr->parentItem; + if (ptr == item) + lv->d->highlighted = 0; + } + + nChildren--; + + Q3ListViewItem ** nextChild = &childItem; + while(nextChild && *nextChild && item != *nextChild) + nextChild = &((*nextChild)->siblingItem); + + if (nextChild && item == *nextChild) + *nextChild = (*nextChild)->siblingItem; + item->parentItem = 0; + item->siblingItem = 0; + item->ownHeight = 0; + item->maybeTotalHeight = -1; + item->configured = false; + + if (emit_changed) { + emit lv->currentChanged(lv->d->focusItem); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(lv->viewport(), 0, QAccessible::Focus); +#endif + } +} + + +/*! + \fn QString Q3ListViewItem::key(int column, bool ascending) const + + Returns a key that can be used for sorting by column \a column. + The default implementation returns text(). Derived classes may + also incorporate the order indicated by \a ascending into this + key, although this is not recommended. + + If you want to sort on non-alphabetical data, e.g. dates, numbers, + etc., it is more efficient to reimplement compare(). + + \sa compare(), sortChildItems() +*/ + +QString Q3ListViewItem::key(int column, bool) const +{ + return text(column); +} + + +/*! + Compares this list view item to \a i using the column \a col in \a + ascending order. Returns \< 0 if this item is less than \a i, 0 if + they are equal and \> 0 if this item is greater than \a i. + + This function is used for sorting. + + The default implementation compares the item keys (key()) using + QString::localeAwareCompare(). A reimplementation can use + different values and a different comparison function. Here is a + reimplementation that uses plain Unicode comparison: + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 3 + We don't recommend using \a ascending so your code can safely + ignore it. + + \sa key() QString::localeAwareCompare() QString::compare() +*/ + +int Q3ListViewItem::compare(Q3ListViewItem *i, int col, bool ascending) const +{ + return key(col, ascending).localeAwareCompare(i->key(col, ascending)); +} + +/*! + Sorts this item's children using column \a column. This is done in + ascending order if \a ascending is true and in descending order if + \a ascending is false. + + Asks some of the children to sort their children. (Q3ListView and + Q3ListViewItem ensure that all on-screen objects are properly + sorted but may avoid or defer sorting other objects in order to be + more responsive.) + + \sa key() compare() +*/ + +void Q3ListViewItem::sortChildItems(int column, bool ascending) +{ + // we try HARD not to sort. if we're already sorted, don't. + if (column == (int)lsc && ascending == (bool)lso) + return; + + if (column < 0) + return; + + lsc = column; + lso = ascending; + + const int nColumns = (listView() ? listView()->columns() : 0); + + // and don't sort if we already have the right sorting order + if (column > nColumns || childItem == 0 || childItem->siblingItem == 0) + return; + + // make an array for qHeapSort() + Q3ListViewPrivate::SortableItem * siblings + = new Q3ListViewPrivate::SortableItem[nChildren]; + Q3ListViewItem * s = childItem; + int i = 0; + while (s && i < nChildren) { + siblings[i].numCols = nColumns; + siblings[i].col = column; + siblings[i].asc = ascending; + siblings[i].item = s; + s = s->siblingItem; + i++; + } + + // and sort it. + qHeapSort(siblings, siblings + nChildren); + + // build the linked list of siblings, in the appropriate + // direction, and finally set this->childItem to the new top + // child. + if (ascending) { + for(i = 0; i < nChildren - 1; i++) + siblings[i].item->siblingItem = siblings[i+1].item; + siblings[nChildren-1].item->siblingItem = 0; + childItem = siblings[0].item; + } else { + for(i = nChildren - 1; i > 0; i--) + siblings[i].item->siblingItem = siblings[i-1].item; + siblings[0].item->siblingItem = 0; + childItem = siblings[nChildren-1].item; + } + for (i = 0; i < nChildren; i++) { + if (siblings[i].item->isOpen()) + siblings[i].item->sort(); + } + delete[] siblings; +} + + +/*! + Sets this item's height to \a height pixels. This implicitly + changes totalHeight(), too. + + Note that a font change causes this height to be overwritten + unless you reimplement setup(). + + For best results in Windows style we suggest using an even number + of pixels. + + \sa height() totalHeight() isOpen() +*/ + +void Q3ListViewItem::setHeight(int height) +{ + if (ownHeight != height) { + if (visible) + ownHeight = height; + else + ownHeight = 0; + invalidateHeight(); + } +} + + +/*! + Invalidates the cached total height of this item, including all + open children. + + \sa setHeight() height() totalHeight() +*/ + +void Q3ListViewItem::invalidateHeight() +{ + if (maybeTotalHeight < 0) + return; + maybeTotalHeight = -1; + if (parentItem && parentItem->isOpen()) + parentItem->invalidateHeight(); +} + + +/*! + Opens or closes an item, i.e. shows or hides an item's children. + + If \a o is true all child items are shown initially. The user can + hide them by clicking the \bold{-} icon to the left of the item. + If \a o is false, the children of this item are initially hidden. + The user can show them by clicking the \bold{+} icon to the left + of the item. + + \sa height() totalHeight() isOpen() +*/ + +void Q3ListViewItem::setOpen(bool o) +{ + if (o == (bool)open || !enabled) + return; + open = o; + + // If no children to show simply emit signals and return + if (!nChildren) { + Q3ListView *lv = listView(); + if (lv && this != lv->d->r) { + if (o) + emit lv->expanded(this); + else + emit lv->collapsed(this); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(lv->viewport(), indexOfItem(this), QAccessible::StateChanged); +#endif + } + return; + } + invalidateHeight(); + + if (!configured) { + Q3ListViewItem * l = this; + QStack<Q3ListViewItem *> s; + while(l) { + if (l->open && l->childItem) { + s.push(l->childItem); + } else if (l->childItem) { + // first invisible child is unconfigured + Q3ListViewItem * c = l->childItem; + while(c) { + c->configured = false; + c = c->siblingItem; + } + } + l->configured = true; + l->setup(); + l = (l == this) ? 0 : l->siblingItem; + if (!l && !s.isEmpty()) + l = s.pop(); + } + } + + Q3ListView *lv = listView(); + + if (open && lv) + enforceSortOrder(); + + if (isVisible() && lv && lv->d && !lv->d->drawables.isEmpty()) + lv->buildDrawableList(); + + if (lv && this != lv->d->r) { + if (o) + emit lv->expanded(this); + else + emit lv->collapsed(this); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(lv->viewport(), indexOfItem(this), QAccessible::StateChanged); +#endif + } +} + + +/*! + This virtual function is called before the first time Q3ListView + needs to know the height or any other graphical attribute of this + object, and whenever the font, GUI style, or colors of the list + view change. + + The default calls widthChanged() and sets the item's height to the + height of a single line of text in the list view's font. (If you + use icons, multi-line text, etc., you will probably need to call + setHeight() yourself or reimplement it.) +*/ + +void Q3ListViewItem::setup() +{ + widthChanged(); + Q3ListView *lv = listView(); + + int ph = 0; + int h = 0; + if (lv) { + for (int i = 0; i < lv->d->column.size(); ++i) { + if (pixmap(i)) + ph = qMax(ph, pixmap(i)->height()); + } + + if (mlenabled) { + h = ph; + for (int c = 0; c < lv->columns(); ++c) { + int lines = text(c).count(QLatin1Char('\n')) + 1; + int tmph = lv->d->fontMetricsHeight + + lv->fontMetrics().lineSpacing() * (lines - 1); + h = qMax(h, tmph); + } + h += 2*lv->itemMargin(); + } else { + h = qMax(lv->d->fontMetricsHeight, ph) + 2*lv->itemMargin(); + } + } + + h = qMax(h, QApplication::globalStrut().height()); + + if (h % 2 > 0) + h++; + setHeight(h); +} + + + + +/*! + This virtual function is called whenever the user presses the mouse + on this item or presses Space on it. + + \sa activatedPos() +*/ + +void Q3ListViewItem::activate() +{ +} + + +/*! + When called from a reimplementation of activate(), this function + gives information on how the item was activated. Otherwise the + behavior is undefined. + + If activate() was caused by a mouse press, the function sets \a + pos to where the user clicked and returns true; otherwise it + returns false and does not change \a pos. + + \a pos is relative to the top-left corner of this item. + + \sa activate() +*/ + +bool Q3ListViewItem::activatedPos(QPoint &pos) +{ + if (activatedByClick) + pos = activatedP; + return activatedByClick; +} + + +/*! + \fn bool Q3ListViewItem::isSelectable() const + + Returns true if the item is selectable (as it is by default); + otherwise returns false + + \sa setSelectable() +*/ + + +/*! + Sets this items to be selectable if \a enable is true (the + default) or not to be selectable if \a enable is false. + + The user is not able to select a non-selectable item using either + the keyboard or the mouse. The application programmer still can + though, e.g. using setSelected(). + + \sa isSelectable() +*/ + +void Q3ListViewItem::setSelectable(bool enable) +{ + selectable = enable; +} + + +/*! + \fn bool Q3ListViewItem::isExpandable() const + + Returns true if this item is expandable even when it has no + children; otherwise returns false. +*/ + +/*! + Sets this item to be expandable even if it has no children if \a + enable is true, and to be expandable only if it has children if \a + enable is false (the default). + + The dirview example uses this in the canonical fashion. It checks + whether the directory is empty in setup() and calls + setExpandable(true) if not; in setOpen() it reads the contents of + the directory and inserts items accordingly. This strategy means + that dirview can display the entire file system without reading + very much at startup. + + Note that root items are not expandable by the user unless + Q3ListView::setRootIsDecorated() is set to true. + + \sa setSelectable() +*/ + +void Q3ListViewItem::setExpandable(bool enable) +{ + expandable = enable; +} + + +/*! + Makes sure that this object's children are sorted appropriately. + + This only works if every item from the root item down to this item + is already sorted. + + \sa sortChildItems() +*/ + +void Q3ListViewItem::enforceSortOrder() const +{ + Q3ListView *lv = listView(); + if (!lv || (lv && (lv->d->clearing || lv->d->sortcolumn == Unsorted))) + return; + if (parentItem && + (parentItem->lsc != lsc || parentItem->lso != lso)) + ((Q3ListViewItem *)this)->sortChildItems((int)parentItem->lsc, + (bool)parentItem->lso); + else if (!parentItem && + ((int)lsc != lv->d->sortcolumn || (bool)lso != lv->d->ascending)) + ((Q3ListViewItem *)this)->sortChildItems(lv->d->sortcolumn, lv->d->ascending); +} + + +/*! + \fn bool Q3ListViewItem::isSelected() const + + Returns true if this item is selected; otherwise returns false. + + \sa setSelected() Q3ListView::setSelected() Q3ListView::selectionChanged() +*/ + + +/*! + If \a s is true this item is selected; otherwise it is deselected. + + This function does not maintain any invariants or repaint anything + -- Q3ListView::setSelected() does that. + + \sa height() totalHeight() +*/ + +void Q3ListViewItem::setSelected(bool s) +{ + bool old = selected; + + Q3ListView *lv = listView(); + if (lv && lv->selectionMode() != Q3ListView::NoSelection) { + if (s && isSelectable()) + selected = true; + else + selected = false; + +#ifndef QT_NO_ACCESSIBILITY + if (old != (bool)selected) { + int ind = indexOfItem(this); + QAccessible::updateAccessibility(lv->viewport(), ind, QAccessible::StateChanged); + QAccessible::updateAccessibility(lv->viewport(), ind, selected ? QAccessible::SelectionAdd : QAccessible::SelectionRemove); + } +#else + Q_UNUSED(old); +#endif + } +} + +/*! + Returns the total height of this object, including any visible + children. This height is recomputed lazily and cached for as long + as possible. + + Functions which can affect the total height are, setHeight() which + is used to set an item's height, setOpen() to show or hide an + item's children, and invalidateHeight() to invalidate the cached + height. + + \sa height() +*/ + +int Q3ListViewItem::totalHeight() const +{ + if (!visible) + return 0; + if (maybeTotalHeight >= 0) + return maybeTotalHeight; + Q3ListViewItem * that = (Q3ListViewItem *)this; + if (!that->configured) { + that->configured = true; + that->setup(); // ### virtual non-const function called in const + } + that->maybeTotalHeight = that->ownHeight; + + if (!that->isOpen() || !that->childCount()) + return that->ownHeight; + + Q3ListViewItem * child = that->childItem; + while (child != 0) { + that->maybeTotalHeight += child->totalHeight(); + child = child->siblingItem; + } + return that->maybeTotalHeight; +} + + +/*! + Returns the text in column \a column, or an empty string if there is + no text in that column. + + \sa key() paintCell() +*/ + +QString Q3ListViewItem::text(int column) const +{ + Q3ListViewPrivate::ItemColumnInfo * l + = (Q3ListViewPrivate::ItemColumnInfo*) columns; + + while(column && l) { + l = l->next; + column--; + } + + return l ? l->text : QString(); +} + + +/*! + Sets the text in column \a column to \a text, if \a column is a + valid column number and \a text is different from the existing + text. + + If the text() function has been reimplemented, this function may + be a no-op. + + \sa text() key() +*/ + +void Q3ListViewItem::setText(int column, const QString &text) +{ + if (column < 0) + return; + + Q3ListViewPrivate::ItemColumnInfo * l + = (Q3ListViewPrivate::ItemColumnInfo*) columns; + if (!l) { + l = new Q3ListViewPrivate::ItemColumnInfo; + columns = (void*)l; + } + for(int c = 0; c < column; c++) { + if (!l->next) + l->next = new Q3ListViewPrivate::ItemColumnInfo; + l = l->next; + } + if (l->text == text) + return; + + int oldLc = 0; + int newLc = 0; + if (mlenabled) { + if (!l->text.isEmpty()) + oldLc = l->text.count(QLatin1Char('\n')) + 1; + if (!text.isEmpty()) + newLc = text.count(QLatin1Char('\n')) + 1; + } + + l->dirty = true; + l->text = text; + if (column == (int)lsc) + lsc = Unsorted; + + if (mlenabled && oldLc != newLc) + setup(); + else + widthChanged(column); + + Q3ListView * lv = listView(); + if (lv) { + lv->triggerUpdate(); +#ifndef QT_NO_ACCESSIBILITY + if (lv->isVisible()) + QAccessible::updateAccessibility(lv->viewport(), indexOfItem(this), QAccessible::NameChanged); +#endif + } +} + + +/*! + Sets the pixmap in column \a column to \a pm, if \a pm is non-null + and different from the current pixmap, and if \a column is + non-negative. + + \sa pixmap() setText() +*/ + +void Q3ListViewItem::setPixmap(int column, const QPixmap & pm) +{ + if (column < 0) + return; + + int oldW = 0; + int oldH = 0; + if (pixmap(column)) { + oldW = pixmap(column)->width(); + oldH = pixmap(column)->height(); + } + + Q3ListViewPrivate::ItemColumnInfo * l + = (Q3ListViewPrivate::ItemColumnInfo*) columns; + if (!l) { + l = new Q3ListViewPrivate::ItemColumnInfo; + columns = (void*)l; + } + + for(int c = 0; c < column; c++) { + if (!l->next) + l->next = new Q3ListViewPrivate::ItemColumnInfo; + l = l->next; + } + + if ((pm.isNull() && (!l->pm || l->pm->isNull())) || + (l->pm && pm.serialNumber() == l->pm->serialNumber())) + return; + + if (pm.isNull()) { + delete l->pm; + l->pm = 0; + } else { + if (l->pm) + *(l->pm) = pm; + else + l->pm = new QPixmap(pm); + } + + int newW = 0; + int newH = 0; + if (pixmap(column)) { + newW = pixmap(column)->width(); + newH = pixmap(column)->height(); + } + + if (oldW != newW || oldH != newH) { + setup(); + widthChanged(column); + invalidateHeight(); + } + Q3ListView *lv = listView(); + if (lv) { + lv->triggerUpdate(); + } +} + + +/*! + Returns the pixmap for \a column, or 0 if there is no pixmap for + \a column. + + \sa setText() setPixmap() +*/ + +const QPixmap * Q3ListViewItem::pixmap(int column) const +{ + Q3ListViewPrivate::ItemColumnInfo * l + = (Q3ListViewPrivate::ItemColumnInfo*) columns; + + while(column && l) { + l = l->next; + column--; + } + + return (l && l->pm) ? l->pm : 0; +} + + +/* + This function paints the contents of one column of an item + and aligns it as described by \a align. + + \a p is a QPainter open on the relevant paint device. \a p is + translated so (0, 0) is the top-left pixel in the cell and \a + width-1, height()-1 is the bottom-right pixel \e in the cell. The + other properties of \a p (pen, brush, etc) are undefined. \a pal is + the color group to use. \a column is the logical column number + within the item that is to be painted; 0 is the column which may + contain a tree. + + This function may use Q3ListView::itemMargin() for readability + spacing on the left and right sides of data such as text, and + should honor isSelected() and Q3ListView::allColumnsShowFocus(). + + If you reimplement this function, you should also reimplement + width(). + + The rectangle to be painted is in an undefined state when this + function is called, so you \e must draw on all the pixels. The + painter \a p has the right font on entry. + + \sa paintBranches(), Q3ListView::drawContentsOffset() +*/ + +static QStyleOptionQ3ListView getStyleOption(const Q3ListView *lv, const Q3ListViewItem *item, + bool hierarchy = false) +{ + QStyleOptionQ3ListView opt; + opt.init(lv); + opt.subControls = QStyle::SC_None; + opt.activeSubControls = QStyle::SC_None; + QWidget *vp = lv->viewport(); + opt.viewportPalette = vp->palette(); + opt.viewportBGRole = vp->backgroundRole(); + opt.itemMargin = lv->itemMargin(); + opt.sortColumn = 0; + opt.treeStepSize = lv->treeStepSize(); + opt.rootIsDecorated = lv->rootIsDecorated(); + bool firstItem = true; + int y = item ? item->itemPos() : 0; + while (item) { + QStyleOptionQ3ListViewItem lvi; + lvi.height = item->height(); + lvi.totalHeight = item->totalHeight(); + lvi.itemY = y; + lvi.childCount = item->childCount(); + lvi.features = QStyleOptionQ3ListViewItem::None; + lvi.state = QStyle::State_None; + if (item->isEnabled()) + lvi.state |= QStyle::State_Enabled; + if (item->isOpen()) + lvi.state |= QStyle::State_Open; + if (item->isExpandable()) + lvi.features |= QStyleOptionQ3ListViewItem::Expandable; + if (item->multiLinesEnabled()) + lvi.features |= QStyleOptionQ3ListViewItem::MultiLine; + if (item->isVisible()) + lvi.features |= QStyleOptionQ3ListViewItem::Visible; + if (item->parent() && item->parent()->rtti() == 1 + && static_cast<Q3CheckListItem *>(item->parent())->type() == Q3CheckListItem::Controller) + lvi.features |= QStyleOptionQ3ListViewItem::ParentControl; + opt.items.append(lvi); + // we only care about the children when we are painting the branches + // this is only enabled by Q3ListViewItem::paintBranches + if (hierarchy) { + if (!firstItem) { + item = item->nextSibling(); + } else { + firstItem = false; + item = item->firstChild(); + } + y += lvi.height; + } else { + break; + } + } + return opt; +} + +/*! + \fn void Q3ListViewItem::paintCell(QPainter *painter, const QColorGroup & cg, int column, int width, int align) + + This virtual function paints the contents of one column of an item + and aligns it as described by \a align. + + The \a painter is a Q3Painter open on the relevant paint + device. It is translated so (0, 0) is the top-left pixel in the + cell and \a width - 1, height() - 1 is the bottom-right pixel \e + in the cell. The other properties of the \a painter (pen, brush, etc) are + undefined. \a cg is the color group to use. \a column is the + logical column number within the item that is to be painted; 0 is + the column which may contain a tree. + + This function may use Q3ListView::itemMargin() for readability + spacing on the left and right sides of data such as text, and + should honor \l isSelected() and + Q3ListView::allColumnsShowFocus(). + + If you reimplement this function, you should also reimplement \l + width(). + + The rectangle to be painted is in an undefined state when this + function is called, so you \e must draw on all the pixels. The + \a painter has the right font on entry. + + \sa paintBranches(), Q3ListView::drawContentsOffset() +*/ +void Q3ListViewItem::paintCell(QPainter * p, const QColorGroup & cg, + int column, int width, int align) +{ + // Change width() if you change this. + + QPalette pal = cg; + if (!p) + return; + + Q3ListView *lv = listView(); + if (!lv) + return; + QFontMetrics fm(p->fontMetrics()); + + // had, but we _need_ the column info for the ellipsis thingy!!! + if (!columns) { + for (int i = 0; i < lv->d->column.size(); ++i) { + setText(i, text(i)); + } + } + + QString t = text(column); + + if (columns) { + Q3ListViewPrivate::ItemColumnInfo *ci = 0; + // try until we have a column info.... + while (!ci) { + ci = (Q3ListViewPrivate::ItemColumnInfo*)columns; + for (int i = 0; ci && (i < column); ++i) + ci = ci->next; + + if (!ci) { + setText(column, t); + ci = 0; + } + } + + // if the column width changed and this item was not painted since this change + if (ci && (ci->width != width || ci->text != t || ci->dirty)) { + ci->text = t; + ci->dirty = false; + ci->width = width; + ci->truncated = false; + // if we have to do the ellipsis thingy calc the truncated text + int pw = lv->itemMargin()*2 - lv->d->minLeftBearing - lv->d->minRightBearing; + pw += pixmap(column) ? pixmap(column)->width() + lv->itemMargin() : 0; + if (!mlenabled && fm.width(t) + pw > width) { + // take care of arabic shaping in width calculation (lars) + ci->truncated = true; + ci->tmpText = qEllipsisText(t, fm, width - pw, align); + } else if (mlenabled && fm.width(t) + pw > width) { + QStringList list = t.split(QLatin1Char('\n')); + for (QStringList::Iterator it = list.begin(); it != list.end(); ++it) { + QString z = *it; + if (fm.width(z) + pw > width) { + ci->truncated = true; + *it = qEllipsisText(z, fm, width - pw, align); + } + } + + if (ci->truncated) + ci->tmpText = list.join(QString(QLatin1Char('\n'))); + } + } + + // if we have to draw the ellipsis thingy, use the truncated text + if (ci && ci->truncated) + t = ci->tmpText; + } + + int marg = lv->itemMargin(); + int r = marg; + const QPixmap * icon = pixmap(column); + + const QPalette::ColorRole crole = lv->viewport()->backgroundRole(); + if (pal.brush(crole) != lv->palette().brush(pal.currentColorGroup(), crole)) + p->fillRect(0, 0, width, height(), pal.brush(crole)); + else + lv->paintEmptyArea(p, QRect(0, 0, width, height())); + + // (lars) what does this do??? +#if 0 // RS: #### + if (align != Qt::AlignLeft) + marg -= lv->d->minRightBearing; +#endif + if (isSelected() && + (column == 0 || lv->allColumnsShowFocus())) { + p->fillRect(r - marg, 0, qMax(0, width - r + marg), height(), + pal.brush(QPalette::Highlight)); + if (enabled || !lv) + p->setPen(pal.highlightedText().color()); + else if (!enabled && lv) + p->setPen(lv->palette().color(QPalette::Disabled, QPalette::HighlightedText)); + } else { + if (enabled || !lv) + p->setPen(pal.text().color()); + else if (!enabled && lv) + p->setPen(lv->palette().color(QPalette::Disabled, QPalette::Text)); + } + + +#if 0 + bool reverse = QApplication::reverseLayout(); +#else + bool reverse = false; +#endif + int iconWidth = 0; + + if (icon) { + iconWidth = icon->width() + lv->itemMargin(); + int xo = r; + // we default to Qt::AlignVCenter. + int yo = (height() - icon->height()) / 2; + + // I guess we may as well always respect vertical alignment. + if (align & Qt::AlignBottom) + yo = height() - icon->height(); + else if (align & Qt::AlignTop) + yo = 0; + + // respect horizontal alignment when there is no text for an item. + if (text(column).isEmpty()) { + if (align & Qt::AlignRight) + xo = width - 2 * marg - iconWidth; + else if (align & Qt::AlignHCenter) + xo = (width - iconWidth) / 2; + } + if (reverse) + xo = width - 2 * marg - iconWidth; + p->drawPixmap(xo, yo, *icon); + } + + if (!t.isEmpty()) { + if (!mlenabled) { + if (!(align & Qt::AlignTop || align & Qt::AlignBottom)) + align |= Qt::AlignVCenter; + } else { + if (!(align & Qt::AlignVCenter || align & Qt::AlignBottom)) + align |= Qt::AlignTop; + } + if (!reverse) + r += iconWidth; + + if (!mlenabled) { + p->drawText(r, 0, width-marg-r, height(), align, t); + } else { + p->drawText(r, marg, width-marg-r, height(), align, t); + } + } + + if (mlenabled && column == 0 && isOpen() && childCount()) { + int textheight = fm.size(align, t).height() + 2 * lv->itemMargin(); + textheight = qMax(textheight, QApplication::globalStrut().height()); + if (textheight % 2 > 0) + textheight++; + if (textheight < height()) { + int w = lv->treeStepSize() / 2; + QStyleOptionQ3ListView opt = getStyleOption(lv, this); + opt.rect.setRect(0, textheight, w + 1, height() - textheight + 1); + opt.palette = pal; + opt.subControls = QStyle::SC_Q3ListViewExpand; + opt.activeSubControls = QStyle::SC_All; + lv->style()->drawComplexControl(QStyle::CC_Q3ListView, &opt, p, lv); + } + } +} + +/*! + Returns the number of pixels of width required to draw column \a c + of list view \a lv, using the metrics \a fm without cropping. The + list view containing this item may use this information depending + on the Q3ListView::WidthMode settings for the column. + + The default implementation returns the width of the bounding + rectangle of the text of column \a c. + + \sa listView() widthChanged() Q3ListView::setColumnWidthMode() + Q3ListView::itemMargin() +*/ +int Q3ListViewItem::width(const QFontMetrics& fm, + const Q3ListView* lv, int c) const +{ + int w; + if (mlenabled) + w = fm.size(Qt::AlignVCenter, text(c)).width() + lv->itemMargin() * 2 + - lv->d->minLeftBearing - lv->d->minRightBearing; + else + w = fm.width(text(c)) + lv->itemMargin() * 2 + - lv->d->minLeftBearing - lv->d->minRightBearing; + const QPixmap * pm = pixmap(c); + if (pm) + w += pm->width() + lv->itemMargin(); // ### correct margin stuff? + return qMax(w, QApplication::globalStrut().width()); +} + + +/*! + Paints a focus indicator on the rectangle \a r using painter \a p + and colors \a cg. + + \a p is already clipped. + + \sa paintCell() paintBranches() Q3ListView::setAllColumnsShowFocus() +*/ + +void Q3ListViewItem::paintFocus(QPainter *p, const QColorGroup &cg, const QRect &r) +{ + QPalette pal = cg; + Q3ListView *lv = listView(); + if (lv) { + QStyleOptionFocusRect opt; + opt.init(lv); + opt.rect = r; + opt.palette = pal; + opt.state |= QStyle::State_KeyboardFocusChange; + if (isSelected()) { + opt.state |= QStyle::State_FocusAtBorder; + opt.backgroundColor = pal.highlight().color(); + } else { + opt.state |= QStyle::State_None; + opt.backgroundColor = pal.base().color(); + } + lv->style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p, lv); + } +} + + +/*! + Paints a set of branches from this item to (some of) its children. + + Painter \a p is set up with clipping and translation so that you + can only draw in the rectangle that needs redrawing; \a cg is the + color group to use; the update rectangle is at (0, 0) and has size + width \a w by height \a h. The top of the rectangle you own is at + \a y (which is never greater than 0 but can be outside the window + system's allowed coordinate range). + + The update rectangle is in an undefined state when this function + is called; this function must draw on \e all of the pixels. + + \sa paintCell(), Q3ListView::drawContentsOffset() +*/ + +void Q3ListViewItem::paintBranches(QPainter * p, const QColorGroup & cg, + int w, int y, int h) +{ + Q3ListView *lv = listView(); + if (lv) + lv->paintEmptyArea(p, QRect(0, 0, w, h)); + if (!visible || !lv) + return; + QStyleOptionQ3ListView opt = getStyleOption(lv, this, true); + opt.rect.setRect(0, y, w, h); + opt.palette = cg; + opt.subControls = QStyle::SC_Q3ListViewBranch | QStyle::SC_Q3ListViewExpand; + opt.activeSubControls = QStyle::SC_None; + lv->style()->drawComplexControl(QStyle::CC_Q3ListView, &opt, p, lv); +} + + +Q3ListViewPrivate::Root::Root(Q3ListView * parent) + : Q3ListViewItem(parent) +{ + lv = parent; + setHeight(0); + setOpen(true); +} + + +void Q3ListViewPrivate::Root::setHeight(int) +{ + Q3ListViewItem::setHeight(0); +} + + +void Q3ListViewPrivate::Root::invalidateHeight() +{ + Q3ListViewItem::invalidateHeight(); + lv->triggerUpdate(); +} + + +Q3ListView * Q3ListViewPrivate::Root::theListView() const +{ + return lv; +} + + +void Q3ListViewPrivate::Root::setup() +{ + // explicitly nothing +} + + + +/*! +\internal +If called after a mouse click, tells the list view to ignore a +following double click. This state is reset after the next mouse click. +*/ + +void Q3ListViewItem::ignoreDoubleClick() +{ + Q3ListView *lv = listView(); + if (lv) + lv->d->ignoreDoubleClick = true; +} + + + +/*! + \fn void Q3ListView::onItem(Q3ListViewItem *i) + + This signal is emitted when the user moves the mouse cursor onto + item \a i, similar to the QWidget::enterEvent() function. +*/ + +// ### bug here too? see qiconview.cppp onItem/onViewport + +/*! + \fn void Q3ListView::onViewport() + + This signal is emitted when the user moves the mouse cursor from + an item to an empty part of the list view. +*/ + +/*! + \enum Q3ListView::SelectionMode + + This enumerated type is used by Q3ListView to indicate how it + reacts to selection by the user. + + \value Single When the user selects an item, any already-selected + item becomes unselected, and the user cannot unselect the selected + item. + + \value Multi When the user selects an item in the usual way, the + selection status of that item is toggled and the other items are + left alone. + + \value Extended When the user selects an item in the usual way, + the selection is cleared and the new item selected. However, if + the user presses the Ctrl key when clicking on an item, the + clicked item gets toggled and all other items are left untouched. + And if the user presses the Shift key while clicking on an item, + all items between the current item and the clicked item get + selected or unselected, depending on the state of the clicked + item. Also, multiple items can be selected by dragging the mouse + over them. + + \value NoSelection Items cannot be selected. + + In other words, \c Single is a real single-selection list view, \c + Multi a real multi-selection list view, \c Extended is a list view + where users can select multiple items but usually want to select + either just one or a range of contiguous items, and \c NoSelection + is a list view where the user can look but not touch. +*/ + +/*! + \enum Q3ListView::ResizeMode + + This enum describes how the list view's header adjusts to resize + events which affect the width of the list view. + + \value NoColumn The columns do not get resized in resize events. + + \value AllColumns All columns are resized equally to fit the width + of the list view. + + \value LastColumn The last column is resized to fit the width of + the list view. +*/ + +/*! + \enum Q3ListView::RenameAction + + This enum describes whether a rename operation is accepted if the + rename editor loses focus without the user pressing Enter. + + \value Accept Rename if Enter is pressed or focus is lost. + + \value Reject Discard the rename operation if focus is lost (and + Enter has not been pressed). +*/ + +/*! + \class Q3ListView + \brief The Q3ListView class implements a list/tree view. + + \compat + + It can display and control a hierarchy of multi-column items, and + provides the ability to add new items at any time. The user may + select one or many items (depending on the \c SelectionMode) and + sort the list in increasing or decreasing order by any column. + + The simplest pattern of use is to create a Q3ListView, add some + column headers using addColumn() and create one or more + Q3ListViewItem or Q3CheckListItem objects with the Q3ListView as + parent. + + Further nodes can be added to the list view object (the root of the + tree) or as child nodes to Q3ListViewItems. + + The main setup functions are: + \table + \header \i Function \i Action + \row \i \l addColumn() + \i Adds a column with a text label and perhaps width. Columns + are counted from the left starting with column 0. + \row \i \l setColumnWidthMode() + \i Sets the column to be resized automatically or not. + \row \i \l setAllColumnsShowFocus() + \i Sets whether items should show keyboard focus using all + columns or just column 0. The default is to show focus + just using column 0. + \row \i \l setRootIsDecorated() + \i Sets whether root items can be opened and closed by the + user and have open/close decoration to their left. The + default is false. + \row \i \l setTreeStepSize() + \i Sets how many pixels an item's children are indented + relative to their parent. The default is 20. This is + mostly a matter of taste. + \row \i \l setSorting() + \i Sets whether the items should be sorted, whether it should + be in ascending or descending order, and by what column + they should be sorted. By default the list view is sorted + by the first column; to switch this off call setSorting(-1). + \endtable + + There are several functions for mapping between items and + coordinates. itemAt() returns the item at a position on-screen, + itemRect() returns the rectangle an item occupies on the screen, + and itemPos() returns the position of any item (whether it is + on-screen or not). firstChild() returns the list view's first item + (not necessarily visible on-screen). + + You can iterate over visible items using + Q3ListViewItem::itemBelow(); over a list view's top-level items + using Q3ListViewItem::firstChild() and + Q3ListViewItem::nextSibling(); or every item using a + Q3ListViewItemIterator. See + the Q3ListViewItem documentation for examples of traversal. + + An item can be moved amongst its siblings using + Q3ListViewItem::moveItem(). To move an item in the hierarchy use + takeItem() and insertItem(). Item's (and all their child items) + are deleted with \c delete; to delete all the list view's items + use clear(). + + There are a variety of selection modes described in the + Q3ListView::SelectionMode documentation. The default is \c Single + selection, which you can change using setSelectionMode(). + + Because Q3ListView offers multiple selection it must display + keyboard focus and selection state separately. Therefore there are + functions both to set the selection state of an item + (setSelected()) and to set which item displays keyboard focus + (setCurrentItem()). + + Q3ListView emits two groups of signals; one group signals changes + in selection/focus state and one indicates selection. The first + group consists of selectionChanged() (applicable to all list + views), selectionChanged(Q3ListViewItem*) (applicable only to a + \c Single selection list view), and currentChanged(Q3ListViewItem*). + The second group consists of doubleClicked(Q3ListViewItem*), + returnPressed(Q3ListViewItem*), + rightButtonClicked(Q3ListViewItem*, const QPoint&, int), etc. + + Note that changing the state of the list view in a slot connected + to a list view signal may cause unexpected side effects. If you + need to change the list view's state in response to a signal, use + a \link QTimer::singleShot() single shot timer\endlink with a + time out of 0, and connect this timer to a slot that modifies the + list view's state. + + In Motif style, Q3ListView deviates fairly strongly from the look + and feel of the Motif hierarchical tree view. This is done mostly + to provide a usable keyboard interface and to make the list view + look better with a white background. + + If selectionMode() is \c Single (the default) the user can select + one item at a time, e.g. by clicking an item with the mouse, see + \l Q3ListView::SelectionMode for details. + + The list view can be navigated either using the mouse or the + keyboard. Clicking a \bold{-} icon closes an item (hides its + children) and clicking a \bold{+} icon opens an item (shows its + children). The keyboard controls are these: + \table + \header \i Keypress \i Action + \row \i Home + \i Make the first item current and visible. + \row \i End + \i Make the last item current and visible. + \row \i Page Up + \i Make the item above the top visible item current and visible. + \row \i Page Down + \i Make the item below the bottom visible item current and visible. + \row \i Up Arrow + \i Make the item above the current item current and visible. + \row \i Down Arrow + \i Make the item below the current item current and visible. + \row \i Left Arrow + \i If the current item is closed (\bold{+} icon) or has no + children, make its parent item current and visible. If the + current item is open (\bold{-} icon) close it, i.e. hide its + children. Exception: if the current item is the first item + and is closed and the horizontal scroll bar is offset to + the right the list view will be scrolled left. + \row \i Right Arrow + \i If the current item is closed (\bold{+} icon) and has + children, the item is opened. If the current item is + opened (\bold{-} icon) and has children the item's first + child is made current and visible. If the current item has + no children the list view is scrolled right. + \endtable + + If the user starts typing letters with the focus in the list view + an incremental search will occur. For example if the user types + 'd' the current item will change to the first item that begins + with the letter 'd'; if they then type 'a', the current item will + change to the first item that begins with 'da', and so on. If no + item begins with the letters they type the current item doesn't + change. + + Note that the list view's size hint is calculated taking into + account the height \e and width to produce a nice aspect ratio. + This may mean that you need to reimplement sizeHint() in some + cases. + + \warning The list view assumes ownership of all list view items + and will delete them when it does not need them any more. + + \sa Q3ListViewItem Q3CheckListItem +*/ + +/*! + \fn void Q3ListView::itemRenamed(Q3ListViewItem * item, int col) + + \overload + + This signal is emitted when \a item has been renamed, e.g. by + in-place renaming, in column \a col. + + \sa Q3ListViewItem::setRenameEnabled() +*/ + +/*! + \fn void Q3ListView::itemRenamed(Q3ListViewItem * item, int col, const QString &text) + + This signal is emitted when \a item has been renamed to \a text, + e.g. by in in-place renaming, in column \a col. + + \sa Q3ListViewItem::setRenameEnabled() +*/ + +/*! + Constructs a new empty list view called \a name with parent \a + parent and widget attributes \a f. + + This constructor sets the \c WA_StaticContent and the \c + Qt::WA_NoBackground attributes to boost performance when drawing + Q3ListViewItems. This may be unsuitable for custom Q3ListViewItem + classes, in which case Qt::WA_StaticContents and Qt::WA_NoBackground + should be cleared on the viewport() after construction. + + \sa QWidget::setAttribute() +*/ +Q3ListView::Q3ListView(QWidget * parent, const char *name, Qt::WindowFlags f) + : Q3ScrollView(parent, name, f | Qt::WStaticContents | Qt::WNoAutoErase) +{ + init(); +} + +void Q3ListView::init() +{ + d = new Q3ListViewPrivate; + d->vci = 0; + d->timer = new QTimer(this); + d->levelWidth = 20; + d->r = 0; + d->rootIsExpandable = 0; + d->h = new Q3Header(this, "list view header"); + d->h->installEventFilter(this); + d->focusItem = 0; + d->oldFocusItem = 0; + d->dirtyItemTimer = new QTimer(this); + d->visibleTimer = new QTimer(this); + d->renameTimer = new QTimer(this); + d->autoopenTimer = new QTimer(this); + d->margin = 1; + d->selectionMode = Q3ListView::Single; + d->sortcolumn = 0; + d->ascending = true; + d->allColumnsShowFocus = false; + d->fontMetricsHeight = fontMetrics().height(); + d->h->setTracking(true); + d->buttonDown = false; + d->ignoreDoubleClick = false; + d->scrollTimer = 0; + d->sortIndicator = false; + d->clearing = false; + d->minLeftBearing = fontMetrics().minLeftBearing(); + d->minRightBearing = fontMetrics().minRightBearing(); + d->ellipsisWidth = fontMetrics().width(QLatin1String("...")) * 2; + d->highlighted = 0; + d->pressedItem = 0; + d->selectAnchor = 0; + d->select = true; + d->startDragItem = 0; + d->toolTips = true; + d->updateHeader = false; + d->fullRepaintOnComlumnChange = false; + d->resizeMode = NoColumn; + d->defRenameAction = Reject; + d->pressedEmptyArea = false; + d->startEdit = true; + d->ignoreEditAfterFocus = false; + d->inMenuMode = false; + d->pressedSelected = false; + + setMouseTracking(true); + viewport()->setMouseTracking(true); + + connect(d->timer, SIGNAL(timeout()), + this, SLOT(updateContents())); + connect(d->dirtyItemTimer, SIGNAL(timeout()), + this, SLOT(updateDirtyItems())); + connect(d->visibleTimer, SIGNAL(timeout()), + this, SLOT(makeVisible())); + connect(d->renameTimer, SIGNAL(timeout()), + this, SLOT(startRename())); + connect(d->autoopenTimer, SIGNAL(timeout()), + this, SLOT(openFocusItem())); + + connect(d->h, SIGNAL(sizeChange(int,int,int)), + this, SLOT(handleSizeChange(int,int,int))); + connect(d->h, SIGNAL(indexChange(int,int,int)), + this, SLOT(handleIndexChange())); + connect(d->h, SIGNAL(sectionClicked(int)), + this, SLOT(changeSortColumn(int))); + connect(d->h, SIGNAL(sectionHandleDoubleClicked(int)), + this, SLOT(adjustColumn(int))); + connect(horizontalScrollBar(), SIGNAL(sliderMoved(int)), + d->h, SLOT(setOffset(int))); + connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), + d->h, SLOT(setOffset(int))); + + // will access d->r + Q3ListViewPrivate::Root * r = new Q3ListViewPrivate::Root(this); + r->is_root = true; + d->r = r; + d->r->setSelectable(false); + + viewport()->setFocusProxy(this); + viewport()->setFocusPolicy(Qt::WheelFocus); + setFocusPolicy(Qt::WheelFocus); + viewport()->setBackgroundRole(QPalette::Base); + setAttribute(Qt::WA_MacShowFocusRect); +} + +/*! + \property Q3ListView::showSortIndicator + \brief whether the list view header should display a sort indicator. + + If this property is true, an arrow is drawn in the header of the + list view to indicate the sort order of the list view contents. + The arrow will be drawn in the correct column and will point up or + down, depending on the current sort direction. The default is + false (don't show an indicator). + + \sa Q3Header::setSortIndicator() +*/ + +void Q3ListView::setShowSortIndicator(bool show) +{ + if (show == d->sortIndicator) + return; + + d->sortIndicator = show; + if (d->sortcolumn != Unsorted && d->sortIndicator) + d->h->setSortIndicator(d->sortcolumn, d->ascending); + else + d->h->setSortIndicator(-1); +} + +bool Q3ListView::showSortIndicator() const +{ + return d->sortIndicator; +} + +/*! + \property Q3ListView::showToolTips + \brief whether this list view should show tooltips for truncated column texts + + The default is true. +*/ + +void Q3ListView::setShowToolTips(bool b) +{ + d->toolTips = b; +} + +bool Q3ListView::showToolTips() const +{ + return d->toolTips; +} + +/*! + \property Q3ListView::resizeMode + \brief whether all, none or the only the last column should be resized + + Specifies whether all, none or only the last column should be + resized to fit the full width of the list view. The values for this + property can be one of: \c NoColumn (the default), \c AllColumns + or \c LastColumn. + + \warning Setting the resize mode should be done after all necessary + columns have been added to the list view, otherwise the behavior is + undefined. + + \sa Q3Header, header() +*/ + +void Q3ListView::setResizeMode(ResizeMode m) +{ + d->resizeMode = m; + if (m == NoColumn) + header()->setStretchEnabled(false); + else if (m == AllColumns) + header()->setStretchEnabled(true); + else + header()->setStretchEnabled(true, header()->count() - 1); +} + +Q3ListView::ResizeMode Q3ListView::resizeMode() const +{ + return d->resizeMode; +} + +/*! + Destroys the list view, deleting all its items, and frees up all + allocated resources. +*/ + +Q3ListView::~Q3ListView() +{ + for (int j = 0; j < d->iterators.size(); ++j) { + Q3ListViewItemIterator *i = d->iterators.at(j); + i->listView = 0; + } + + d->focusItem = 0; + delete d->r; + d->r = 0; + delete d->vci; + d->vci = 0; +#if 0 + delete d->toolTip; + d->toolTip = 0; +#endif + delete d; + d = 0; +} + + +/*! + Calls Q3ListViewItem::paintCell() and + Q3ListViewItem::paintBranches() as necessary for all list view + items that require repainting in the \a cw pixels wide and \a ch + pixels high bounding rectangle starting at position \a cx, \a cy + with offset \a ox, \a oy. Uses the painter \a p. +*/ + +void Q3ListView::drawContentsOffset(QPainter * p, int ox, int oy, + int cx, int cy, int cw, int ch) +{ + if (columns() == 0) { + paintEmptyArea(p, QRect(cx, cy, cw, ch)); + return; + } + + if (d->drawables.isEmpty() || + d->topPixel > cy || + d->bottomPixel < cy + ch - 1 || + d->r->maybeTotalHeight < 0) + buildDrawableList(); + + if (!d->dirtyItems.isEmpty()) { + QRect br(cx - ox, cy - oy, cw, ch); + for (int i = 0; i < d->dirtyItems.size(); ++i) { + const Q3ListViewItem * item = d->dirtyItems.at(i); + QRect ir = itemRect(item).intersected(viewport()->visibleRect()); + if (ir.isEmpty() || br.contains(ir)) + // we're painting this one, or it needs no painting: forget it + d->dirtyItems.removeAt(i); + } + if (d->dirtyItems.count()) { + // there are still items left that need repainting + d->dirtyItemTimer->start(0, true); + } else { + // we're painting all items that need to be painted + d->dirtyItems.clear(); + d->dirtyItemTimer->stop(); + } + } + + p->setFont(font()); + + QRect r; + int fx = -1, x, fc = 0, lc = 0; + int tx = -1; + + for (int i = 0; i < d->drawables.size(); ++i) { + Q3ListViewPrivate::DrawableItem current = d->drawables.at(i); + if (!current.i->isVisible()) + continue; + int ih = current.i->height(); + int ith = current.i->totalHeight(); + int c; + int cs; + + // need to paint current? + if (ih > 0 && current.y < cy+ch && current.y+ih > cy) { + if (fx < 0) { + // find first interesting column, once + x = 0; + c = 0; + cs = d->h->cellSize(0); + while (x + cs <= cx && c < d->h->count()) { + x += cs; + c++; + if (c < d->h->count()) + cs = d->h->cellSize(c); + } + fx = x; + fc = c; + while(x < cx + cw && c < d->h->count()) { + x += cs; + c++; + if (c < d->h->count()) + cs = d->h->cellSize(c); + } + lc = c; + } + + x = fx; + c = fc; + // draw to last interesting column + + bool drawActiveSelection = hasFocus() || d->inMenuMode || + !style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this) + || (currentItem() && currentItem()->renameBox + && currentItem()->renameBox->hasFocus()); + QPalette pal = palette(); + if(!drawActiveSelection) + pal.setCurrentColorGroup(QPalette::Inactive); + + while (c < lc) { + int i = d->h->mapToLogical(c); + cs = d->h->cellSize(c); + r.setRect(x - ox, current.y - oy, cs, ih); + if (i == 0 && current.i->parentItem) + r.setLeft(r.left() + current.l * treeStepSize()); + + p->save(); + // No need to paint if the cell isn't technically visible + if (!(r.width() == 0 || r.height() == 0)) { + p->translate(r.left(), r.top()); + int ac = d->h->mapToLogical(c); + // map to Left currently. This should change once we + // can really reverse the listview. + int align = columnAlignment(ac); + if (align == Qt::AlignAuto) align = Qt::AlignLeft; + current.i->paintCell(p, pal, ac, r.width(), align); + } + p->restore(); + x += cs; + c++; + } + + if (current.i == d->focusItem && hasFocus() && + !d->allColumnsShowFocus) { + p->save(); + int cell = d->h->mapToActual(0); + QRect r(d->h->cellPos(cell) - ox, current.y - oy, d->h->cellSize(cell), ih); + if (current.i->parentItem) + r.setLeft(r.left() + current.l * treeStepSize()); + if (r.left() < r.right()) + current.i->paintFocus(p, palette(), r); + p->restore(); + } + } + + const int cell = d->h->mapToActual(0); + + // does current need focus indication? + if (current.i == d->focusItem && hasFocus() && + d->allColumnsShowFocus) { + p->save(); + int x = -contentsX(); + int w = header()->cellPos(header()->count() - 1) + + header()->cellSize(header()->count() - 1); + + r.setRect(x, current.y - oy, w, ih); + if (d->h->mapToActual(0) == 0 || (current.l == 0 && !rootIsDecorated())) { + int offsetx = qMin(current.l * treeStepSize(), d->h->cellSize(cell)); + r.setLeft(r.left() + offsetx); + current.i->paintFocus(p, palette(), r); + } else { + int xdepth = qMin(treeStepSize() * (current.i->depth() + (rootIsDecorated() ? 1 : 0)) + + itemMargin(), d->h->cellSize(cell)); + xdepth += d->h->cellPos(cell); + QRect r1(r); + r1.setRight(d->h->cellPos(cell) - 1); + QRect r2(r); + r2.setLeft(xdepth - 1); + current.i->paintFocus(p, palette(), r1); + current.i->paintFocus(p, palette(), r2); + } + p->restore(); + } + + if (tx < 0) + tx = d->h->cellPos(cell); + + // do any children of current need to be painted? + if (ih != ith && + (current.i != d->r || d->rootIsExpandable) && + current.y + ith > cy && + current.y + ih < cy + ch && + tx + current.l * treeStepSize() < cx + cw && + tx + (current.l+1) * treeStepSize() > cx) { + // compute the clip rectangle the safe way + + int rtop = current.y + ih; + int rbottom = current.y + ith; + int rleft = tx + current.l*treeStepSize(); + int rright = rleft + treeStepSize(); + + int crtop = qMax(rtop, cy); + int crbottom = qMin(rbottom, cy+ch); + int crleft = qMax(rleft, cx); + int crright = qMin(rright, cx+cw); + + r.setRect(crleft-ox, crtop-oy, + crright-crleft, crbottom-crtop); + + if (r.isValid()) { + p->save(); + p->setClipRect(QRect(d->h->cellPos(cell), 0, d->h->cellSize(cell), height())); + p->translate(rleft-ox, crtop-oy); + + current.i->paintBranches(p, palette(), treeStepSize(), + rtop - crtop, r.height()); + p->restore(); + } + } + } + + if (d->r->totalHeight() < cy + ch) + paintEmptyArea(p, QRect(cx - ox, d->r->totalHeight() - oy, + cw, cy + ch - d->r->totalHeight())); + + int c = d->h->count()-1; + if (c >= 0 && + d->h->cellPos(c) + d->h->cellSize(c) < cx + cw) { + c = d->h->cellPos(c) + d->h->cellSize(c); + paintEmptyArea(p, QRect(c - ox, cy - oy, cx + cw - c, ch)); + } +} + + + +/*! + Paints \a rect so that it looks like empty background using + painter \a p. \a rect is in widget coordinates, ready to be fed to + \a p. + + The default function fills \a rect with the + viewport()->backgroundBrush(). +*/ + +void Q3ListView::paintEmptyArea(QPainter * p, const QRect & rect) +{ + QStyleOptionQ3ListView opt = getStyleOption(this, 0); + opt.rect = rect; + opt.sortColumn = d->sortcolumn; + opt.subControls = QStyle::SC_Q3ListView; + style()->drawComplexControl(QStyle::CC_Q3ListView, &opt, p, this); +} + + +/* + Rebuilds the list of drawable Q3ListViewItems. This function is + const so that const functions can call it without requiring + d->drawables to be mutable. +*/ + +void Q3ListView::buildDrawableList() const +{ + d->r->enforceSortOrder(); + + QStack<Q3ListViewPrivate::DrawableItem> stack; + Q3ListViewPrivate::DrawableItem di(((int)d->rootIsExpandable)-1, 0, d->r); + stack.push(di); + + Q3ListView *that = const_cast<Q3ListView *>(this); + + // could mess with cy and ch in order to speed up vertical + // scrolling + int cy = contentsY(); + int ch = that->visibleHeight(); + d->topPixel = cy + ch; // one below bottom + d->bottomPixel = cy - 1; // one above top + + that->d->drawables.clear(); + + while (!stack.isEmpty()) { + Q3ListViewPrivate::DrawableItem cur = stack.pop(); + + int ih = cur.i->height(); + int ith = cur.i->totalHeight(); + + // is this item, or its branch symbol, inside the viewport? + if (cur.y + ith >= cy && cur.y < cy + ch) { + that->d->drawables.append(cur); + // perhaps adjust topPixel up to this item? may be adjusted + // down again if any children are not to be painted + if (cur.y < d->topPixel) + d->topPixel = cur.y; + // bottompixel is easy: the bottom item drawn contains it + d->bottomPixel = cur.y + ih - 1; + } + + // push younger sibling of cur on the stack? + if (cur.y + ith < cy+ch && cur.i->siblingItem) + stack.push(Q3ListViewPrivate::DrawableItem(cur.l, cur.y + ith, cur.i->siblingItem)); + + // do any children of cur need to be painted? + if (cur.i->isOpen() && cur.i->childCount() && + cur.y + ith > cy && + cur.y + ih < cy + ch) { + cur.i->enforceSortOrder(); + + Q3ListViewItem * c = cur.i->childItem; + int y = cur.y + ih; + + // if any of the children are not to be painted, skip them + // and invalidate topPixel + while (c && y + c->totalHeight() <= cy) { + y += c->totalHeight(); + c = c->siblingItem; + d->topPixel = cy + ch; + } + + // push one child on the stack, if there is at least one + // needing to be painted + if (c && y < cy+ch) + stack.push(Q3ListViewPrivate::DrawableItem(cur.l + 1, y, c)); + } + } +} + +/*! + \property Q3ListView::treeStepSize + \brief the number of pixels a child is offset from its parent + + The default is 20 pixels. + + Of course, this property is only meaningful for hierarchical list + views. +*/ + +int Q3ListView::treeStepSize() const +{ + return d->levelWidth; +} + +void Q3ListView::setTreeStepSize(int size) +{ + if (size != d->levelWidth) { + d->levelWidth = size; + viewport()->repaint(); + } +} + +/*! + Inserts item \a i into the list view as a top-level item. You do + not need to call this unless you've called takeItem(\a i) or + Q3ListViewItem::takeItem(\a i) and need to reinsert \a i elsewhere. + + \sa Q3ListViewItem::takeItem() takeItem() +*/ + +void Q3ListView::insertItem(Q3ListViewItem * i) +{ + if (d->r) // not for d->r itself + d->r->insertItem(i); +} + + +/*! + Removes and deletes all the items in this list view and triggers + an update. + + \sa triggerUpdate() +*/ + +void Q3ListView::clear() +{ + bool wasUpdatesEnabled = viewport()->updatesEnabled(); + if (wasUpdatesEnabled) + viewport()->setUpdatesEnabled(false); + setContentsPos(0, 0); + if (wasUpdatesEnabled) + viewport()->setUpdatesEnabled(true); + + bool block = signalsBlocked(); + blockSignals(true); + d->clearing = true; + clearSelection(); + for (int j = 0; j < d->iterators.size(); ++j) { + Q3ListViewItemIterator *i = d->iterators.at(j); + i->curr = 0; + } + + d->drawables.clear(); + d->dirtyItems.clear(); + d->dirtyItemTimer->stop(); + + d->highlighted = 0; + d->focusItem = 0; + d->selectAnchor = 0; + d->pressedItem = 0; + d->startDragItem = 0; + + // if it's down its downness makes no sense, so undown it + d->buttonDown = false; + + Q3ListViewItem *c = (Q3ListViewItem *)d->r->firstChild(); + Q3ListViewItem *n; + while(c) { + n = (Q3ListViewItem *)c->nextSibling(); + delete c; + c = n; + } + resizeContents(d->h->sizeHint().width(), contentsHeight()); + delete d->r; + d->r = 0; + Q3ListViewPrivate::Root * r = new Q3ListViewPrivate::Root(this); + r->is_root = true; + d->r = r; + d->r->setSelectable(false); + blockSignals(block); + triggerUpdate(); + d->clearing = false; +} + +/*! + \reimp +*/ + +void Q3ListView::setContentsPos(int x, int y) +{ + updateGeometries(); + Q3ScrollView::setContentsPos(x, y); +} + +/*! + Adds a \a width pixels wide column with the column header \a label + to the list view, and returns the index of the new column. + + All columns apart from the first one are inserted to the right of + the existing ones. + + If \a width is negative, the new column's \l WidthMode is set to + \c Maximum instead of \c Manual. + + \sa setColumnText() setColumnWidth() setColumnWidthMode() +*/ +int Q3ListView::addColumn(const QString &label, int width) +{ + int c = d->h->addLabel(label, width); + d->column.resize(c+1); + d->column[c].wmode = (width >= 0 ? Manual : Maximum); + updateGeometries(); + updateGeometry(); + return c; +} + +/*! + \overload + + Adds a \a width pixels wide new column with the header \a label + and the \a icon to the list view, and returns the index of the + column. + + If \a width is negative, the new column's \l WidthMode is set to + \c Maximum, and to \c Manual otherwise. + + \sa setColumnText() setColumnWidth() setColumnWidthMode() +*/ +int Q3ListView::addColumn(const QIcon& icon, const QString &label, int width) +{ + int c = d->h->addLabel(icon, label, width); + d->column.resize(c+1); + d->column[c].wmode = (width >= 0 ? Manual : Maximum); + updateGeometries(); + updateGeometry(); + return c; +} + +/*! + \property Q3ListView::columns + \brief the number of columns in this list view + + \sa addColumn(), removeColumn() +*/ + +int Q3ListView::columns() const +{ + return d->column.count(); +} + +/*! + Removes the column at position \a index. +*/ + +void Q3ListView::removeColumn(int index) +{ + if (index < 0 || index > (int)d->column.count() - 1) + return; + + if (d->vci) { + Q3ListViewPrivate::ViewColumnInfo *vi = d->vci, *prev = 0, *next = 0; + for (int i = 0; i < index; ++i) { + if (vi) { + prev = vi; + vi = vi->next; + } + } + if (vi) { + next = vi->next; + if (prev) + prev->next = next; + vi->next = 0; + delete vi; + if (index == 0) + d->vci = next; + } + } + + Q3ListViewItemIterator it(this); + for (; it.current(); ++it) { + Q3ListViewPrivate::ItemColumnInfo *ci = (Q3ListViewPrivate::ItemColumnInfo*)it.current()->columns; + if (ci) { + Q3ListViewPrivate::ItemColumnInfo *prev = 0, *next = 0; + for (int i = 0; i < index; ++i) { + if (ci) { + prev = ci; + ci = ci->next; + } + } + if (ci) { + next = ci->next; + if (prev) + prev->next = next; + ci->next = 0; + delete ci; + if (index == 0) + it.current()->columns = next; + } + } + } + + for (int i = index; i < (int)d->column.size() - 1; ++i) + d->column[i] = d->column[i + 1]; + d->column.resize(d->column.size() - 1); + + d->h->removeLabel(index); + if (d->resizeMode == LastColumn) + d->h->setStretchEnabled(true, d->h->count() - 1); + + updateGeometries(); + if (d->column.count() == 0) + clear(); + updateGeometry(); + viewport()->update(); +} + +/*! + Sets the heading of column \a column to \a label. + + \sa columnText() +*/ +void Q3ListView::setColumnText(int column, const QString &label) +{ + if (column < d->h->count()) { + d->h->setLabel(column, label); + updateGeometries(); + updateGeometry(); + } +} + +/*! + \overload + + Sets the heading of column \a column to \a icon and \a label. + + \sa columnText() +*/ +void Q3ListView::setColumnText(int column, const QIcon& icon, const QString &label) +{ + if (column < d->h->count()) { + d->h->setLabel(column, icon, label); + updateGeometries(); + } +} + +/*! + Sets the width of column \a column to \a w pixels. Note that if + the column has a \c WidthMode other than \c Manual, this width + setting may be subsequently overridden. + + \sa columnWidth() +*/ +void Q3ListView::setColumnWidth(int column, int w) +{ + int oldw = d->h->sectionSize(column); + if (column < d->h->count() && oldw != w) { + d->h->resizeSection(column, w); + disconnect(d->h, SIGNAL(sizeChange(int,int,int)), + this, SLOT(handleSizeChange(int,int,int))); + emit d->h->sizeChange(column, oldw, w); + connect(d->h, SIGNAL(sizeChange(int,int,int)), + this, SLOT(handleSizeChange(int,int,int))); + viewport()->update(); + } +} + + +/*! + Returns the text of column \a c. + + \sa setColumnText() +*/ + +QString Q3ListView::columnText(int c) const +{ + return d->h->label(c); +} + +/*! + Returns the width of column \a c. + + \sa setColumnWidth() +*/ + +int Q3ListView::columnWidth(int c) const +{ + int actual = d->h->mapToActual(c); + return d->h->cellSize(actual); +} + + +/*! + \enum Q3ListView::WidthMode + + This enum type describes how the width of a column in the view + changes. + + \value Manual the column width does not change automatically. + + \value Maximum the column is automatically sized according to the + widths of all items in the column. (Note: The column never shrinks + in this case.) This means that the column is always resized to the + width of the item with the largest width in the column. + + \sa setColumnWidth() setColumnWidthMode() columnWidth() +*/ + + +/*! + Sets column \a{c}'s width mode to \a mode. The default depends on + the original width argument to addColumn(). + + \sa Q3ListViewItem::width() +*/ + +void Q3ListView::setColumnWidthMode(int c, WidthMode mode) +{ + if (c >= 0 && c < d->h->count()) + d->column[c].wmode = mode; +} + + +/*! + Returns the \c WidthMode for column \a c. + + \sa setColumnWidthMode() +*/ + +Q3ListView::WidthMode Q3ListView::columnWidthMode(int c) const +{ + if (c >= 0 && c < d->h->count()) + return d->column[c].wmode; + else + return Manual; +} + + +/*! + Sets column \a{column}'s alignment to \a align. The alignment is + ultimately passed to Q3ListViewItem::paintCell() for each item in + the list view. For horizontally aligned text with Qt::AlignLeft or + Qt::AlignHCenter the ellipsis (...) will be to the right, for + Qt::AlignRight the ellipsis will be to the left. + + \sa Qt::Alignment +*/ + +void Q3ListView::setColumnAlignment(int column, int align) +{ + if (column < 0) + return; + if (!d->vci) + d->vci = new Q3ListViewPrivate::ViewColumnInfo; + Q3ListViewPrivate::ViewColumnInfo * l = d->vci; + while(column) { + if (!l->next) + l->next = new Q3ListViewPrivate::ViewColumnInfo; + l = l->next; + column--; + } + if (l->align == align) + return; + l->align = align; + triggerUpdate(); +} + + +/*! + Returns the alignment of column \a column. The default is \c + Qt::AlignAuto. + + \sa Qt::Alignment +*/ + +int Q3ListView::columnAlignment(int column) const +{ + if (column < 0 || !d->vci) + return Qt::AlignAuto; + Q3ListViewPrivate::ViewColumnInfo * l = d->vci; + while(column) { + if (!l->next) + l->next = new Q3ListViewPrivate::ViewColumnInfo; + l = l->next; + column--; + } + return l ? l->align : Qt::AlignAuto; +} + + + +/*! + \internal +*/ +void Q3ListView::show() +{ + // Reimplemented to setx the correct background mode and viewed + // area size. + if (!isVisible()) { + reconfigureItems(); + updateGeometries(); + } + Q3ScrollView::show(); +} + + +/*! + Updates the sizes of the viewport, header, scroll bars and so on. + + \warning Don't call this directly; call triggerUpdate() instead. +*/ + +void Q3ListView::updateContents() +{ + if (d->updateHeader) + header()->adjustHeaderSize(); + d->updateHeader = false; + if (!isVisible()) { + // Not in response to a setText/setPixmap any more. + return; + } + d->drawables.clear(); + viewport()->setUpdatesEnabled(false); + updateGeometries(); + viewport()->setUpdatesEnabled(true); + viewport()->repaint(); +} + + +void Q3ListView::updateGeometries() +{ + int th = d->r->totalHeight(); + int tw = d->h->headerWidth(); + if (d->h->offset() && + tw < d->h->offset() + d->h->width()) + horizontalScrollBar()->setValue(tw - Q3ListView::d->h->width()); +#if 0 + if (QApplication::reverseLayout() && d->h->offset() != horizontalScrollBar()->value()) + horizontalScrollBar()->setValue(d->h->offset()); +#endif + verticalScrollBar()->raise(); + resizeContents(tw, th); + d->drawables.clear(); + if (d->h->isHidden()) { + setMargins(0, 0, 0, 0); + } else { + QSize hs(d->h->sizeHint()); + setMargins(0, hs.height(), 0, 0); + d->h->setGeometry(viewport()->x(), viewport()->y()-hs.height(), + visibleWidth(), hs.height()); + } +} + + +/*! + Updates the display when the section \a section has changed size + from the old size, \a os, to the new size, \a ns. +*/ + +void Q3ListView::handleSizeChange(int section, int os, int ns) +{ + bool upe = viewport()->updatesEnabled(); + if (upe) + viewport()->setUpdatesEnabled(false); + viewport()->setAttribute(Qt::WA_UpdatesDisabled, true); + int sx = horizontalScrollBar()->value(); + bool sv = horizontalScrollBar()->isVisible(); + updateGeometries(); + bool fullRepaint = d->fullRepaintOnComlumnChange || sx != horizontalScrollBar()->value() + || sv != horizontalScrollBar()->isVisible(); + d->fullRepaintOnComlumnChange = false; + if (upe) + viewport()->setUpdatesEnabled(true); + + if (fullRepaint) { + viewport()->repaint(); + return; + } + + int actual = d->h->mapToActual(section); + int dx = ns - os; + int left = d->h->cellPos(actual) - contentsX() + d->h->cellSize(actual); + if (dx > 0) + left -= dx; + if (left < visibleWidth()) + viewport()->scroll(dx, 0, QRect(left, 0, visibleWidth() - left, visibleHeight())); + viewport()->repaint(left - 4 - d->ellipsisWidth, 0, 4 + d->ellipsisWidth, + visibleHeight()); // border between the items and ellipses width + + // map auto to left for now. Need to fix this once we support + // reverse layout on the listview. + int align = columnAlignment(section); + if (align == Qt::AlignAuto) align = Qt::AlignLeft; + if (align != Qt::AlignAuto && align != Qt::AlignLeft) + viewport()->repaint(d->h->cellPos(actual) - contentsX(), 0, + d->h->cellSize(actual), visibleHeight()); + + if (currentItem() && currentItem()->renameBox) { + QRect r = itemRect(currentItem()); + r = QRect(viewportToContents(r.topLeft()), r.size()); + r.setLeft(header()->sectionPos(currentItem()->renameCol)); + r.setWidth(header()->sectionSize(currentItem()->renameCol) - 1); + if (currentItem()->renameCol == 0) + r.setLeft(r.left() + itemMargin() + (currentItem()->depth() + + (rootIsDecorated() ? 1 : 0)) * treeStepSize() - 1); + if (currentItem()->pixmap(currentItem()->renameCol)) + r.setLeft(r.left() + currentItem()->pixmap(currentItem()->renameCol)->width()); + if (r.x() - contentsX() < 0) + r.setX(contentsX()); + if (r.width() > visibleWidth()) + r.setWidth(visibleWidth()); + addChild(currentItem()->renameBox, r.x(), r.y()); + currentItem()->renameBox->resize(r.size()); + } +} + + +/* + Very smart internal slot that repaints \e only the items that need + to be repainted. Don't use this directly; call repaintItem() + instead. +*/ + +void Q3ListView::updateDirtyItems() +{ + if (d->timer->isActive() || d->dirtyItems.isEmpty()) + return; + QRect ir; + for (int i = 0; i < d->dirtyItems.size(); ++i) { + const Q3ListViewItem *item = d->dirtyItems.at(i); + ir = ir.united(itemRect(item)); + } + d->dirtyItems.clear(); + if (!ir.isEmpty()) { // rectangle to be repainted + if (ir.x() < 0) + ir.moveBy(-ir.x(), 0); + viewport()->repaint(ir); + } +} + + +void Q3ListView::makeVisible() +{ + if (d->focusItem) + ensureItemVisible(d->focusItem); +} + + +/*! + Ensures that the header is correctly sized and positioned when the + resize event \a e occurs. +*/ + +void Q3ListView::resizeEvent(QResizeEvent *e) +{ + Q3ScrollView::resizeEvent(e); + d->fullRepaintOnComlumnChange = true; + d->h->resize(visibleWidth(), d->h->height()); + d->h->adjustHeaderSize(); +} + +/*! \reimp */ + +void Q3ListView::viewportResizeEvent(QResizeEvent *e) +{ + Q3ScrollView::viewportResizeEvent(e); + d->h->resize(visibleWidth(), d->h->height()); + if (resizeMode() != NoColumn && currentItem() && currentItem()->renameBox) { + QRect r = itemRect(currentItem()); + r = QRect(viewportToContents(r.topLeft()), r.size()); + r.setLeft(header()->sectionPos(currentItem()->renameCol)); + r.setWidth(header()->sectionSize(currentItem()->renameCol) - 1); + if (currentItem()->renameCol == 0) + r.setLeft(r.left() + itemMargin() + (currentItem()->depth() + + (rootIsDecorated() ? 1 : 0)) * treeStepSize() - 1); + if (currentItem()->pixmap(currentItem()->renameCol)) + r.setLeft(r.left() + currentItem()->pixmap(currentItem()->renameCol)->width()); + if (r.x() - contentsX() < 0) + r.setX(contentsX()); + if (r.width() > visibleWidth()) + r.setWidth(visibleWidth()); + addChild(currentItem()->renameBox, r.x(), r.y()); + currentItem()->renameBox->resize(r.size()); + } +} + +/*! + Triggers a size, geometry and content update during the next + iteration of the event loop. Ensures that there'll be just one + update to avoid flicker. +*/ + +void Q3ListView::triggerUpdate() +{ + if (!isVisible() || !updatesEnabled()) { + // Not in response to a setText/setPixmap any more. + return; // it will update when shown, or something. + } + + d->timer->start(0, true); +} + + +/*! + Redirects the event \a e relating to object \a o, for the viewport + to mousePressEvent(), keyPressEvent() and friends. +*/ + +bool Q3ListView::eventFilter(QObject * o, QEvent * e) +{ + if (o == d->h && + e->type() >= QEvent::MouseButtonPress && + e->type() <= QEvent::MouseMove) { + QMouseEvent * me = (QMouseEvent *)e; + QMouseEvent me2(me->type(), + QPoint(me->pos().x(), + me->pos().y() - d->h->height()), + me->button(), me->state()); + switch(me2.type()) { + case QEvent::MouseButtonDblClick: + if (me2.button() == Qt::RightButton) + return true; + break; + case QEvent::MouseMove: + if (me2.state() & Qt::RightButton) { + viewportMouseMoveEvent(&me2); + return true; + } + break; + default: + break; + } + } else if (o == viewport()) { + QFocusEvent * fe = (QFocusEvent *)e; + + switch(e->type()) { + case QEvent::FocusIn: + focusInEvent(fe); + return true; + case QEvent::FocusOut: + focusOutEvent(fe); + return true; +#ifndef QT_NO_TOOLTIP + case QEvent::ToolTip: + { + if (!showToolTips()) + return false; + + QHelpEvent *he = static_cast<QHelpEvent *>(e); + Q3ListViewItem *item = itemAt(he->pos()); + QPoint contentsPos = viewportToContents(he->pos()); + if (!item || !item->columns) { + QToolTip::showText(he->globalPos(), QString(), viewport()); + return true; + } + int col = header()->sectionAt(contentsPos.x()); + Q3ListViewPrivate::ItemColumnInfo *ci = (Q3ListViewPrivate::ItemColumnInfo*)item->columns; + for (int i = 0; ci && (i < col); ++i) + ci = ci->next; + + if (!ci || !ci->truncated) + QToolTip::showText(he->globalPos(), QString(), viewport()); + else + QToolTip::showText(he->globalPos(), item->text(col), viewport()); + return true; + } +#endif + default: + // nothing + break; + } + } else if (qobject_cast<QLineEdit*>(o)) { + if (currentItem() && currentItem()->renameBox) { + if (e->type() == QEvent::KeyPress) { + QKeyEvent *ke = (QKeyEvent*)e; + if (ke->key() == Qt::Key_Return || + ke->key() == Qt::Key_Enter) { + currentItem()->okRename(currentItem()->renameCol); + return true; + } else if (ke->key() == Qt::Key_Escape) { + currentItem()->cancelRename(currentItem()->renameCol); + return true; + } + } else if (e->type() == QEvent::FocusOut) { + if (((QFocusEvent*)e)->reason() != Qt::PopupFocusReason) { + QCustomEvent *e = new QCustomEvent(9999); + QApplication::postEvent(o, e); + return true; + } + } else if (e->type() == 9999) { + if (d->defRenameAction == Reject) + currentItem()->cancelRename(currentItem()->renameCol); + else + currentItem()->okRename(currentItem()->renameCol); + return true; + } + } + } + + return Q3ScrollView::eventFilter(o, e); +} + + +/*! + Returns a pointer to the list view containing this item. + + Note that this function traverses the items to the root to find the + listview. This function will return 0 for taken items - see + Q3ListViewItem::takeItem() +*/ + +Q3ListView * Q3ListViewItem::listView() const +{ + const Q3ListViewItem* c = this; + while (c && !c->is_root) + c = c->parentItem; + if (!c) + return 0; + return ((Q3ListViewPrivate::Root*)c)->theListView(); +} + + +/*! + Returns the depth of this item. +*/ +int Q3ListViewItem::depth() const +{ + return parentItem ? parentItem->depth()+1 : -1; // -1 == the hidden root +} + + +/*! + Returns a pointer to the item immediately above this item on the + screen. This is usually the item's closest older sibling, but it + may also be its parent or its next older sibling's youngest child, + or something else if anyoftheabove->height() returns 0. Returns 0 + if there is no item immediately above this item. + + This function assumes that all parents of this item are open (i.e. + that this item is visible, or can be made visible by scrolling). + + This function might be relatively slow because of the tree + traversions needed to find the correct item. + + \sa itemBelow() Q3ListView::itemRect() +*/ + +Q3ListViewItem * Q3ListViewItem::itemAbove() const +{ + if (!parentItem) + return 0; + + Q3ListViewItem * c = parentItem; + if (c->childItem != this) { + c = c->childItem; + while(c && c->siblingItem != this) + c = c->siblingItem; + if (!c) + return 0; + while(c->isOpen() && c->childItem) { + c = c->childItem; + while(c->siblingItem) + c = c->siblingItem; // assign c's sibling to c + } + } + if (c && (!c->height() || !c->isEnabled())) + return c->itemAbove(); + return c; +} + + +/*! + Returns a pointer to the item immediately below this item on the + screen. This is usually the item's eldest child, but it may also + be its next younger sibling, its parent's next younger sibling, + grandparent's, etc., or something else if anyoftheabove->height() + returns 0. Returns 0 if there is no item immediately below this + item. + + This function assumes that all parents of this item are open (i.e. + that this item is visible or can be made visible by scrolling). + + \sa itemAbove() Q3ListView::itemRect() +*/ + +Q3ListViewItem * Q3ListViewItem::itemBelow() const +{ + Q3ListViewItem * c = 0; + if (isOpen() && childItem) { + c = childItem; + } else if (siblingItem) { + c = siblingItem; + } else if (parentItem) { + c = const_cast<Q3ListViewItem*>(this); + do { + c = c->parentItem; + } while(c->parentItem && !c->siblingItem); + if (c) + c = c->siblingItem; + } + if (c && (!c->height() || !c->isEnabled())) + return c->itemBelow(); + return c; +} + + +/*! + \fn bool Q3ListViewItem::isOpen() const + + Returns true if this list view item has children \e and they are + not explicitly hidden; otherwise returns false. + + \sa setOpen() +*/ + +/*! + Returns the first (top) child of this item, or 0 if this item has + no children. + + Note that the children are not guaranteed to be sorted properly. + Q3ListView and Q3ListViewItem try to postpone or avoid sorting to + the greatest degree possible, in order to keep the user interface + snappy. + + \sa nextSibling() sortChildItems() +*/ + +Q3ListViewItem* Q3ListViewItem::firstChild() const +{ + enforceSortOrder(); + return childItem; +} + + +/*! + Returns the parent of this item, or 0 if this item has no parent. + + \sa firstChild(), nextSibling() +*/ + +Q3ListViewItem* Q3ListViewItem::parent() const +{ + if (!parentItem || parentItem->is_root) return 0; + return parentItem; +} + + +/*! + \fn Q3ListViewItem* Q3ListViewItem::nextSibling() const + + Returns the sibling item below this item, or 0 if there is no + sibling item after this item. + + Note that the siblings are not guaranteed to be sorted properly. + Q3ListView and Q3ListViewItem try to postpone or avoid sorting to + the greatest degree possible, in order to keep the user interface + snappy. + + \sa firstChild() sortChildItems() +*/ + +/*! + \fn int Q3ListViewItem::childCount () const + + Returns how many children this item has. The count only includes + the item's immediate children. +*/ + + +/*! + Returns the height of this item in pixels. This does not include + the height of any children; totalHeight() returns that. +*/ +int Q3ListViewItem::height() const +{ + Q3ListViewItem * that = (Q3ListViewItem *)this; + if (!that->configured) { + that->configured = true; + that->setup(); // ### virtual non-const function called in const + } + + return visible ? ownHeight : 0; +} + +/*! + Call this function when the value of width() may have changed for + column \a c. Normally, you should call this if text(c) changes. + Passing -1 for \a c indicates that all columns may have changed. + It is more efficient to pass -1 if two or more columns have + changed than to call widthChanged() separately for each one. + + \sa width() +*/ +void Q3ListViewItem::widthChanged(int c) const +{ + Q3ListView *lv = listView(); + if (lv) + lv->widthChanged(this, c); +} + +/*! + \fn void Q3ListView::dropped (QDropEvent * e) + + This signal is emitted, when a drop event occurred on the + viewport (not onto an item). + + \a e provides all the information about the drop. +*/ + +/*! + \fn void Q3ListView::selectionChanged() + + This signal is emitted whenever the set of selected items has + changed (normally before the screen update). It is available both + in \c Single selection and \c Multi selection mode but is most + useful in \c Multi selection mode. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. + + \sa setSelected() Q3ListViewItem::setSelected() +*/ + + +/*! + \fn void Q3ListView::pressed(Q3ListViewItem *item) + + This signal is emitted whenever the user presses the mouse button + in a list view. \a item is the list view item on which the user + pressed the mouse button, or 0 if the user didn't press the mouse + on an item. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListView::pressed(Q3ListViewItem *item, const QPoint &pnt, int c) + + \overload + + This signal is emitted whenever the user presses the mouse button + in a list view. \a item is the list view item on which the user + pressed the mouse button, or 0 if the user didn't press the mouse + on an item. \a pnt is the position of the mouse cursor in global + coordinates, and \a c is the column where the mouse cursor was + when the user pressed the mouse button. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListView::clicked(Q3ListViewItem *item) + + This signal is emitted whenever the user clicks (mouse pressed \e + and mouse released) in the list view. \a item is the clicked list + view item, or 0 if the user didn't click on an item. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListView::mouseButtonClicked(int button, Q3ListViewItem * item, const QPoint & pos, int c) + + This signal is emitted whenever the user clicks (mouse pressed \e + and mouse released) in the list view at position \a pos. \a button + is the mouse button that the user pressed, \a item is the clicked + list view item or 0 if the user didn't click on an item. If \a + item is not 0, \a c is the list view column into which the user + pressed; if \a item is 0 \a{c}'s value is undefined. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListView::mouseButtonPressed(int button, Q3ListViewItem * item, const QPoint & pos, int c) + + This signal is emitted whenever the user pressed the mouse button + in the list view at position \a pos. \a button is the mouse button + which the user pressed, \a item is the pressed list view item or 0 + if the user didn't press on an item. If \a item is not 0, \a c is + the list view column into which the user pressed; if \a item is 0 + \a{c}'s value is undefined. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListView::clicked(Q3ListViewItem *item, const QPoint &pnt, int c) + + \overload + + This signal is emitted whenever the user clicks (mouse pressed \e + and mouse released) in the list view. \a item is the clicked list + view item, or 0 if the user didn't click on an item. \a pnt is the + position where the user has clicked in global coordinates. If \a + item is not 0, \a c is the list view column into which the user + pressed; if \a item is 0 \a{c}'s value is undefined. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. +*/ + +/*! + \fn void Q3ListView::selectionChanged(Q3ListViewItem *item) + + \overload + + This signal is emitted whenever the selected item has changed in + \c Single selection mode (normally after the screen update). The + argument is the newly selected \a item. + + In \c Multi selection mode, use the no argument overload of this + signal. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. + + \sa setSelected() Q3ListViewItem::setSelected() currentChanged() +*/ + + +/*! + \fn void Q3ListView::currentChanged(Q3ListViewItem *item) + + This signal is emitted whenever the current item has changed + (normally after the screen update). The current item is the item + responsible for indicating keyboard focus. + + The argument is the newly current \a item, or 0 if the change made + no item current. This can happen, for example, if all the items in + the list view are deleted. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. + + \sa setCurrentItem() currentItem() +*/ + + +/*! + \fn void Q3ListView::expanded(Q3ListViewItem *item) + + This signal is emitted when \a item has been expanded, i.e. when + the children of \a item are shown. + + \sa setOpen() collapsed() +*/ + +/*! + \fn void Q3ListView::collapsed(Q3ListViewItem *item) + + This signal is emitted when the \a item has been collapsed, i.e. + when the children of \a item are hidden. + + \sa setOpen() expanded() +*/ + +/*! + Processes the mouse press event \a e on behalf of the viewed widget. +*/ +void Q3ListView::contentsMousePressEvent(QMouseEvent * e) +{ + contentsMousePressEventEx(e); +} + +void Q3ListView::contentsMousePressEventEx(QMouseEvent * e) +{ + if (!e) + return; + + if (!d->ignoreEditAfterFocus) + d->startEdit = true; + d->ignoreEditAfterFocus = false; + + if (currentItem() && currentItem()->renameBox && + !itemRect(currentItem()).contains(e->pos())) { + d->startEdit = false; + if (d->defRenameAction == Reject) + currentItem()->cancelRename(currentItem()->renameCol); + else + currentItem()->okRename(currentItem()->renameCol); + } + + d->startDragItem = 0; + d->dragStartPos = e->pos(); + QPoint vp = contentsToViewport(e->pos()); + + d->ignoreDoubleClick = false; + d->buttonDown = true; + + Q3ListViewItem * i = itemAt(vp); + d->pressedEmptyArea = e->y() > contentsHeight(); + if (i && !i->isEnabled()) + return; + if (d->startEdit && (i != currentItem() || (i && !i->isSelected()))) + d->startEdit = false; + Q3ListViewItem *oldCurrent = currentItem(); + + if (e->button() == Qt::RightButton && (e->state() & Qt::ControlButton)) + goto emit_signals; + + if (!i) { + if (!(e->state() & Qt::ControlButton)) + clearSelection(); + goto emit_signals; + } else { + // No new anchor when using shift + if (!(e->state() & Qt::ShiftButton)) + d->selectAnchor = i; + } + + if ((i->isExpandable() || i->childCount()) && + d->h->mapToLogical(d->h->cellAt(vp.x())) == 0) { + int x1 = vp.x() + + d->h->offset() - + d->h->cellPos(d->h->mapToActual(0)); + int draw = 0; + for (; draw < d->drawables.size(); ++draw) + if (d->drawables.at(draw).i == i) + break; + + if (draw < d->drawables.size()) { + Q3ListViewPrivate::DrawableItem it = d->drawables.at(draw); + QStyleOptionQ3ListView opt = getStyleOption(this, i); + x1 -= treeStepSize() * (it.l - 1); + QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_Q3ListView, &opt, + QPoint(x1, e->pos().y()), this); + if (ctrl == QStyle::SC_Q3ListViewExpand && + e->type() == style()->styleHint(QStyle::SH_Q3ListViewExpand_SelectMouseType, 0, + this)) { + d->buttonDown = false; + if (e->button() == Qt::LeftButton) { + bool close = i->isOpen(); + setOpen(i, !close); + // ### Looks dangerous, removed because of reentrance problems + // qApp->processEvents(); + if (!d->focusItem) { + d->focusItem = i; + repaintItem(d->focusItem); + emit currentChanged(d->focusItem); + } + if (close) { + bool newCurrent = false; + Q3ListViewItem *ci = d->focusItem; + while (ci) { + if (ci->parent() && ci->parent() == i) { + newCurrent = true; + break; + } + ci = ci->parent(); + } + if (newCurrent) { + setCurrentItem(i); + } + } + } + d->ignoreDoubleClick = true; + d->buttonDown = false; + goto emit_signals; + } + } + } + + d->select = d->selectionMode == Multi ? !i->isSelected() : true; + + {// calculate activatedP + activatedByClick = true; + QPoint topLeft = itemRect(i).topLeft(); //### inefficient? + activatedP = vp - topLeft; + int xdepth = treeStepSize() * (i->depth() + (rootIsDecorated() ? 1 : 0)) + + itemMargin(); + xdepth += d->h->sectionPos(d->h->mapToSection(0)); + activatedP.rx() -= xdepth; + } + i->activate(); + activatedByClick = false; + + if (i != d->focusItem) + setCurrentItem(i); + else + repaintItem(i); + + d->pressedSelected = i && i->isSelected(); + + if (i->isSelectable() && selectionMode() != NoSelection) { + if (selectionMode() == Single) + setSelected(i, true); + else if (selectionMode() == Multi) + setSelected(i, d->select); + else if (selectionMode() == Extended) { + bool changed = false; + if (!(e->state() & (Qt::ControlButton | Qt::ShiftButton))) { + if (!i->isSelected()) { + bool blocked = signalsBlocked(); + blockSignals(true); + clearSelection(); + blockSignals(blocked); + i->setSelected(true); + changed = true; + } + } else { + if (e->state() & Qt::ShiftButton) + d->pressedSelected = false; + if ((e->state() & Qt::ControlButton) && !(e->state() & Qt::ShiftButton) && i) { + i->setSelected(!i->isSelected()); + changed = true; + d->pressedSelected = false; + } else if (!oldCurrent || !i || oldCurrent == i) { + if ((bool)i->selected != d->select) { + changed = true; + i->setSelected(d->select); + } + // Shift pressed in Extended mode --- + } else { + changed = selectRange(i, oldCurrent, d->selectAnchor); + } + } + if (changed) { + triggerUpdate(); + emit selectionChanged(); + +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection); +#endif + } + } + } + + emit_signals: + + if (i && !d->buttonDown && + vp.x() + contentsX() < itemMargin() + (i->depth() + (rootIsDecorated() ? 1 : 0)) * treeStepSize()) + i = 0; + d->pressedItem = i; + + int c = i ? d->h->mapToLogical(d->h->cellAt(vp.x())) : -1; + if (!i || (i && i->isEnabled())) { + emit pressed(i); + emit pressed(i, viewport()->mapToGlobal(vp), c); + } + emit mouseButtonPressed(e->button(), i, viewport()->mapToGlobal(vp), c); + + if (e->button() == Qt::RightButton && i == d->pressedItem) { + if (!i && !(e->state() & Qt::ControlButton)) + clearSelection(); + + emit rightButtonPressed(i, viewport()->mapToGlobal(vp), c); + } +} + +/*! + \reimp +*/ + +void Q3ListView::contentsContextMenuEvent(QContextMenuEvent *e) +{ + if (!receivers(SIGNAL(contextMenuRequested(Q3ListViewItem*,QPoint,int)))) { + e->ignore(); + return; + } + if (e->reason() == QContextMenuEvent::Keyboard) { + Q3ListViewItem *item = currentItem(); + if (item) { + QRect r = itemRect(item); + QPoint p = r.topLeft(); + if (allColumnsShowFocus()) + p += QPoint(width() / 2, (r.height() / 2)); + else + p += QPoint(columnWidth(0) / 2, (r.height() / 2)); + p.rx() = qMax(0, p.x()); + p.rx() = qMin(visibleWidth(), p.x()); + emit contextMenuRequested(item, viewport()->mapToGlobal(p), -1); + } + } else { + QPoint vp = contentsToViewport(e->pos()); + Q3ListViewItem * i = itemAt(vp); + int c = i ? d->h->mapToLogical(d->h->cellAt(vp.x())) : -1; + emit contextMenuRequested(i, viewport()->mapToGlobal(vp), c); + } +} + +/*! + Processes the mouse release event \a e on behalf of the viewed widget. +*/ +void Q3ListView::contentsMouseReleaseEvent(QMouseEvent * e) +{ + contentsMouseReleaseEventEx(e); +} + +void Q3ListView::contentsMouseReleaseEventEx(QMouseEvent * e) +{ + d->startDragItem = 0; + bool emitClicked = !d->pressedItem || d->buttonDown; + d->buttonDown = false; + // delete and disconnect autoscroll timer, if we have one + if (d->scrollTimer) { + disconnect(d->scrollTimer, SIGNAL(timeout()), + this, SLOT(doAutoScroll())); + d->scrollTimer->stop(); + delete d->scrollTimer; + d->scrollTimer = 0; + } + + if (!e) + return; + + if (d->selectionMode == Extended && + d->focusItem == d->pressedItem && + d->pressedSelected && d->focusItem && + e->button() == Qt::LeftButton) { + bool block = signalsBlocked(); + blockSignals(true); + clearSelection(); + blockSignals(block); + d->focusItem->setSelected(true); + emit selectionChanged(); +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection); +#endif + } + + QPoint vp = contentsToViewport(e->pos()); + Q3ListViewItem *i = itemAt(vp); + if (i && !i->isEnabled()) + return; + + if (i && i == d->pressedItem && (i->isExpandable() || i->childCount()) && + !d->h->mapToLogical(d->h->cellAt(vp.x())) && e->button() == Qt::LeftButton && + e->type() == style()->styleHint(QStyle::SH_Q3ListViewExpand_SelectMouseType, 0, this)) { + int draw = 0; + for (; draw < d->drawables.size(); ++draw) + if (d->drawables.at(draw).i == i) + break; + if (draw < d->drawables.size()) { + int x1 = vp.x() + d->h->offset() - d->h->cellPos(d->h->mapToActual(0)) - + (treeStepSize() * (d->drawables.at(draw).l - 1)); + QStyleOptionQ3ListView opt = getStyleOption(this, i); + QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_Q3ListView, &opt, + QPoint(x1, e->pos().y()), this); + if (ctrl == QStyle::SC_Q3ListViewExpand) { + bool close = i->isOpen(); + setOpen(i, !close); + // ### Looks dangerous, removed because of reentrance problems + // qApp->processEvents(); + if (!d->focusItem) { + d->focusItem = i; + repaintItem(d->focusItem); + emit currentChanged(d->focusItem); + } + if (close) { + bool newCurrent = false; + Q3ListViewItem *ci = d->focusItem; + while (ci) { + if (ci->parent() && ci->parent() == i) { + newCurrent = true; + break; + } + ci = ci->parent(); + } + if (newCurrent) + setCurrentItem(i); + d->ignoreDoubleClick = true; + } + } + } + } + + if (i == d->pressedItem && i && i->isSelected() && e->button() == Qt::LeftButton && d->startEdit) { + QRect r = itemRect(currentItem()); + r = QRect(viewportToContents(r.topLeft()), r.size()); + d->pressedColumn = header()->sectionAt( e->pos().x()); + r.setLeft(header()->sectionPos(d->pressedColumn)); + r.setWidth(header()->sectionSize(d->pressedColumn) - 1); + if (d->pressedColumn == 0) + r.setLeft(r.left() + itemMargin() + (currentItem()->depth() + + (rootIsDecorated() ? 1 : 0)) * treeStepSize() - 1); + if (r.contains(e->pos()) && + !(e->state() & (Qt::ShiftButton | Qt::ControlButton))) + d->renameTimer->start(QApplication::doubleClickInterval(), true); + } + if (i && vp.x() + contentsX() < itemMargin() + (i->depth() + (rootIsDecorated() ? 1 : 0)) * treeStepSize()) + i = 0; + emitClicked = emitClicked && d->pressedItem == i; + d->pressedItem = 0; + + if (emitClicked) { + if (!i || (i && i->isEnabled())) { + emit clicked(i); + emit clicked(i, viewport()->mapToGlobal(vp), d->h->mapToLogical(d->h->cellAt(vp.x()))); + } + emit mouseButtonClicked(e->button(), i, viewport()->mapToGlobal(vp), + i ? d->h->mapToLogical(d->h->cellAt(vp.x())) : -1); + + if (e->button() == Qt::RightButton) { + if (!i) { + if (!(e->state() & Qt::ControlButton)) + clearSelection(); + emit rightButtonClicked(0, viewport()->mapToGlobal(vp), -1); + return; + } + + int c = d->h->mapToLogical(d->h->cellAt(vp.x())); + emit rightButtonClicked(i, viewport()->mapToGlobal(vp), c); + } + } +} + + +/*! + Processes the mouse double-click event \a e on behalf of the viewed widget. +*/ +void Q3ListView::contentsMouseDoubleClickEvent(QMouseEvent * e) +{ + d->renameTimer->stop(); + d->startEdit = false; + if (!e || e->button() != Qt::LeftButton) + return; + + // ensure that the following mouse moves and eventual release is + // ignored. + d->buttonDown = false; + + if (d->ignoreDoubleClick) { + d->ignoreDoubleClick = false; + return; + } + + QPoint vp = contentsToViewport(e->pos()); + + Q3ListViewItem * i = itemAt(vp); + + // we emit doubleClicked when the item is null (or enabled) to be consistent with + // rightButtonClicked etc. + if (!i || i->isEnabled()) { + int c = d->h->mapToLogical(d->h->cellAt(vp.x())); + emit doubleClicked(i, viewport()->mapToGlobal(vp), c); + } + + if (!i || !i->isEnabled()) + return; + + if (!i->isOpen()) { + if (i->isExpandable() || i->childCount()) + setOpen(i, true); + } else { + setOpen(i, false); + } + + // we emit the 'old' obsolete doubleClicked only if the item is not null and enabled + emit doubleClicked(i); +} + + +/*! + Processes the mouse move event \a e on behalf of the viewed widget. +*/ +void Q3ListView::contentsMouseMoveEvent(QMouseEvent * e) +{ + if (!e) + return; + + bool needAutoScroll = false; + + QPoint vp = contentsToViewport(e->pos()); + + Q3ListViewItem * i = itemAt(vp); + if (i && !i->isEnabled()) + return; + if (i != d->highlighted && + !(d->pressedItem && + (d->pressedItem->isSelected() || d->selectionMode == NoSelection) && + d->pressedItem->dragEnabled())) { + + if (i) { + emit onItem(i); + } else { + emit onViewport(); + } + d->highlighted = i; + } + + if (d->startDragItem) + i = d->startDragItem; + + if (!d->buttonDown || + ((e->state() & Qt::LeftButton) != Qt::LeftButton && + (e->state() & Qt::MidButton) != Qt::MidButton && + (e->state() & Qt::RightButton) != Qt::RightButton)) + return; + + if (d->pressedItem && + (d->pressedItem->isSelected() || d->selectionMode == NoSelection) && + d->pressedItem->dragEnabled()) { + + if (!d->startDragItem) { + setSelected(d->pressedItem, true); + d->startDragItem = d->pressedItem; + } + if ((d->dragStartPos - e->pos()).manhattanLength() > QApplication::startDragDistance()) { + d->buttonDown = false; +#ifndef QT_NO_DRAGANDDROP + startDrag(); +#endif + } + return; + } + + // check, if we need to scroll + if (vp.y() > visibleHeight() || vp.y() < 0) + needAutoScroll = true; + + // if we need to scroll and no autoscroll timer is started, + // connect the timer + if (needAutoScroll && !d->scrollTimer) { + d->scrollTimer = new QTimer(this); + connect(d->scrollTimer, SIGNAL(timeout()), + this, SLOT(doAutoScroll())); + d->scrollTimer->start(100, false); + // call it once manually + doAutoScroll(vp); + } + + // if we don't need to autoscroll + if (!needAutoScroll) { + // if there is a autoscroll timer, delete it + if (d->scrollTimer) { + disconnect(d->scrollTimer, SIGNAL(timeout()), + this, SLOT(doAutoScroll())); + d->scrollTimer->stop(); + delete d->scrollTimer; + d->scrollTimer = 0; + } + // call this to select an item (using the pos from the event) + doAutoScroll(vp); + } +} + + +/*! + This slot handles auto-scrolling when the mouse button is pressed + and the mouse is outside the widget. +*/ +void Q3ListView::doAutoScroll() +{ + doAutoScroll(QPoint()); +} + +/* + Handles auto-scrolling when the mouse button is pressed + and the mouse is outside the widget. + + If cursorPos is (0,0) (isNull == true) it uses the current QCursor::pos, otherwise it uses cursorPos +*/ +void Q3ListView::doAutoScroll(const QPoint &cursorPos) +{ + QPoint pos = cursorPos.isNull() ? viewport()->mapFromGlobal(QCursor::pos()) : cursorPos; + if (!d->focusItem || (d->pressedEmptyArea && pos.y() > contentsHeight())) + return; + + bool down = pos.y() > itemRect(d->focusItem).y(); + + int g = pos.y() + contentsY(); + + if (down && pos.y() > height() ) + g = height() + contentsY(); + else if (pos.y() < 0) + g = contentsY(); + + Q3ListViewItem *c = d->focusItem, *old = 0; + Q3ListViewItem *oldCurrent = c; + if (down) { + int y = itemRect(d->focusItem).y() + contentsY(); + while(c && y + c->height() <= g) { + y += c->height(); + old = c; + c = c->itemBelow(); + } + if (!c && old) + c = old; + } else { + int y = itemRect(d->focusItem).y() + contentsY(); + while(c && y >= g) { + old = c; + c = c->itemAbove(); + if (c) + y -= c->height(); + } + if (!c && old) + c = old; + } + + if (!c || c == d->focusItem) + return; + + if (d->focusItem) { + if (d->selectionMode == Multi) { + // also (de)select the ones in between + Q3ListViewItem * b = d->focusItem; + bool down = (itemPos(c) > itemPos(b)); + while(b && b != c) { + if (b->isSelectable()) + setSelected(b, d->select); + b = down ? b->itemBelow() : b->itemAbove(); + } + if (c->isSelectable()) + setSelected(c, d->select); + } else if (d->selectionMode == Extended) { + if (selectRange(c, oldCurrent, d->selectAnchor)) { + triggerUpdate(); + emit selectionChanged(); + } + } + } + + setCurrentItem(c); + d->visibleTimer->start(1, true); +} + +/*! + \reimp +*/ + +void Q3ListView::focusInEvent(QFocusEvent *e) +{ + d->inMenuMode = false; + if (d->focusItem) { + repaintItem(d->focusItem); + } else if (firstChild() && e->reason() != Qt::MouseFocusReason) { + d->focusItem = firstChild(); + emit currentChanged(d->focusItem); + repaintItem(d->focusItem); + } + if (e->reason() == Qt::MouseFocusReason) { + d->ignoreEditAfterFocus = true; + d->startEdit = false; + } + if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) { + viewport()->repaint(); + } +} + +/*! + \reimp +*/ +QVariant Q3ListView::inputMethodQuery(Qt::InputMethodQuery query) const +{ + if (query == Qt::ImMicroFocus) { + QRect mfrect = itemRect(d->focusItem); + if (mfrect.isValid() && header() && header()->isVisible()) + mfrect.moveBy(0, header()->height()); + return mfrect; + } + return QWidget::inputMethodQuery(query); +} + +/*! + \reimp +*/ + +void Q3ListView::focusOutEvent(QFocusEvent *e) +{ + if (e->reason() == Qt::PopupFocusReason && d->buttonDown) + d->buttonDown = false; + if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) { + d->inMenuMode = + e->reason() == Qt::PopupFocusReason + || (qApp->focusWidget() && qApp->focusWidget()->inherits("QMenuBar")); + if (!d->inMenuMode) { + viewport()->repaint(); + } + } + + if (d->focusItem) + repaintItem(d->focusItem); +} + + +/*! + \reimp +*/ + +void Q3ListView::keyPressEvent(QKeyEvent * e) +{ + if (currentItem() && currentItem()->renameBox) + return; + if (!firstChild()) { + e->ignore(); + return; // subclass bug + } + + Q3ListViewItem* oldCurrent = currentItem(); + if (!oldCurrent) { + setCurrentItem(firstChild()); + if (d->selectionMode == Single) + setSelected(firstChild(), true); + return; + } + + Q3ListViewItem * i = currentItem(); + Q3ListViewItem *old = i; + + QRect r(itemRect(i)); + Q3ListViewItem * i2; + + bool singleStep = false; + bool selectCurrent = true; + bool wasNavigation = true; + + switch(e->key()) { + case Qt::Key_Backspace: + case Qt::Key_Delete: + d->currentPrefix.truncate(0); + break; + case Qt::Key_Enter: + case Qt::Key_Return: + d->currentPrefix.truncate(0); + if (i && !i->isSelectable() && i->isEnabled() && + (i->childCount() || i->isExpandable() || i->isOpen())) { + i->setOpen(!i->isOpen()); + return; + } + e->ignore(); + if (currentItem() && !currentItem()->isEnabled()) + break; + emit returnPressed(currentItem()); + // do NOT accept. QDialog. + return; + case Qt::Key_Down: + selectCurrent = false; + i = i->itemBelow(); + d->currentPrefix.truncate(0); + singleStep = true; + break; + case Qt::Key_Up: + selectCurrent = false; + i = i->itemAbove(); + d->currentPrefix.truncate(0); + singleStep = true; + break; + case Qt::Key_Home: + selectCurrent = false; + i = firstChild(); + if (!i->height() || !i->isEnabled()) + i = i->itemBelow(); + d->currentPrefix.truncate(0); + break; + case Qt::Key_End: + selectCurrent = false; + i = firstChild(); + while (i->nextSibling() && i->nextSibling()->height() && i->nextSibling()->isEnabled()) + i = i->nextSibling(); + while (i->itemBelow()) + i = i->itemBelow(); + d->currentPrefix.truncate(0); + break; + case Qt::Key_Next: + selectCurrent = false; + i2 = itemAt(QPoint(0, visibleHeight()-1)); + if (i2 == i || !r.isValid() || + visibleHeight() <= itemRect(i).bottom()) { + if (i2) + i = i2; + int left = visibleHeight(); + while((i2 = i->itemBelow()) != 0 && left > i2->height()) { + left -= i2->height(); + i = i2; + } + } else { + if (!i2) { + // list is shorter than the view, goto last item + while((i2 = i->itemBelow()) != 0) + i = i2; + } else { + i = i2; + } + } + d->currentPrefix.truncate(0); + break; + case Qt::Key_Prior: + selectCurrent = false; + i2 = itemAt(QPoint(0, 0)); + if (i == i2 || !r.isValid() || r.top() <= 0) { + if (i2) + i = i2; + int left = visibleHeight(); + while((i2 = i->itemAbove()) != 0 && left > i2->height()) { + left -= i2->height(); + i = i2; + } + } else { + i = i2; + } + d->currentPrefix.truncate(0); + break; + case Qt::Key_Plus: + d->currentPrefix.truncate(0); + if ( !i->isOpen() && (i->isExpandable() || i->childCount())) + setOpen(i, true); + else + return; + break; + case Qt::Key_Right: + d->currentPrefix.truncate(0); + if (i->isOpen() && i->childItem) { + i = i->childItem; + } else if (!i->isOpen() && (i->isExpandable() || i->childCount())) { + setOpen(i, true); + } else if (contentsX() + visibleWidth() < contentsWidth()) { + horizontalScrollBar()->triggerAction(QScrollBar::SliderSingleStepAdd); + return; + } else { + return; + } + break; + case Qt::Key_Minus: + d->currentPrefix.truncate(0); + if (i->isOpen()) + setOpen(i, false); + else + return; + break; + case Qt::Key_Left: + d->currentPrefix.truncate(0); + if (i->isOpen()) { + setOpen(i, false); + } else if (i->parentItem && i->parentItem != d->r) { + i = i->parentItem; + } else if (contentsX()) { + horizontalScrollBar()->triggerAction(QScrollBar::SliderSingleStepSub); + return; + } else { + return; + } + break; + case Qt::Key_Space: + activatedByClick = false; + d->currentPrefix.truncate(0); + if (currentItem() && !currentItem()->isEnabled()) + break; + i->activate(); + if (i->isSelectable() && (d->selectionMode == Multi || d->selectionMode == Extended)) { + setSelected(i, !i->isSelected()); + d->currentPrefix.truncate(0); + } + emit spacePressed(currentItem()); + break; + case Qt::Key_Escape: + e->ignore(); // For QDialog + return; + case Qt::Key_F2: + if (currentItem() && currentItem()->renameEnabled(0)) + currentItem()->startRename(0); + default: + if (e->text().length() > 0 && e->text()[0].isPrint()) { + selectCurrent = false; + wasNavigation = false; + QString input(d->currentPrefix); + Q3ListViewItem * keyItem = i; + QTime now(QTime::currentTime()); + bool tryFirst = true; + while(keyItem) { + // try twice, first with the previous string and this char + if (d->currentPrefixTime.msecsTo(now) <= 400) + input = input + e->text().toLower(); + else + input = e->text().toLower(); + if (input.length() == e->text().length()) { + if (keyItem->itemBelow()) { + keyItem = keyItem->itemBelow(); + tryFirst = true; + } else { + keyItem = firstChild(); + tryFirst = false; + } + } + QString keyItemKey; + QString prefix; + while(keyItem) { + keyItemKey = QString::null; + // Look first in the sort column, then left to right + if (d->sortcolumn != Unsorted) + keyItemKey = keyItem->text(d->sortcolumn); + for (int col = 0; col < d->h->count() && keyItemKey.isNull(); ++col) + keyItemKey = keyItem->text(d->h->mapToSection(col)); + if (!keyItemKey.isEmpty()) { + prefix = keyItemKey; + prefix.truncate(input.length()); + prefix = prefix.toLower(); + if (prefix == input) { + d->currentPrefix = input; + d->currentPrefixTime = now; + i = keyItem; + // nonoptimal double-break... + keyItem = 0; + input.truncate(0); + tryFirst = false; + } + } + if (keyItem) + keyItem = keyItem->itemBelow(); + if (!keyItem && tryFirst) { + keyItem = firstChild(); + tryFirst = false; + } + } + // then, if appropriate, with just this character + if (input.length() > e->text().length()) { + input.truncate(0); + keyItem = i; + } + } + } else { + d->currentPrefix.truncate(0); + if (e->state() & Qt::ControlButton) { + d->currentPrefix.clear(); + switch (e->key()) { + case Qt::Key_A: + selectAll(true); + break; + } + } + e->ignore(); + return; + } + } + + if (!i) + return; + + if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor) + d->selectAnchor = i; + + setCurrentItem(i); + if (i->isSelectable()) + handleItemChange(old, wasNavigation && (e->state() & Qt::ShiftButton), + wasNavigation && (e->state() & Qt::ControlButton)); + + if (d->focusItem && !d->focusItem->isSelected() && d->selectionMode == Single && selectCurrent) + setSelected(d->focusItem, true); + + if (singleStep) + d->visibleTimer->start(1, true); + else + ensureItemVisible(i); +} + + +/*! + Returns the list view item at \a viewPos. Note that \a viewPos is + in the viewport()'s coordinate system, not in the list view's own, + much larger, coordinate system. + + itemAt() returns 0 if there is no such item. + + Note that you also get the pointer to the item if \a viewPos + points to the root decoration (see setRootIsDecorated()) of the + item. To check whether or not \a viewPos is on the root decoration + of the item, you can do something like this: + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 4 + + This might be interesting if you use this function to find out + where the user clicked and if you want to start a drag (which you + do not want to do if the user clicked onto the root decoration of + an item). + + \sa itemPos() itemRect() viewportToContents() +*/ + +Q3ListViewItem * Q3ListView::itemAt(const QPoint & viewPos) const +{ + if (viewPos.x() > contentsWidth() - contentsX()) + return 0; + + if (d->drawables.isEmpty()) + buildDrawableList(); + + int g = viewPos.y() + contentsY(); + + for (int i = 0; i < d->drawables.size(); ++i) { + Q3ListViewPrivate::DrawableItem c = d->drawables.at(i); + if (c.y + c.i->height() > g + && c.i->isVisible() && (!c.i->parent() || c.i->parent()->isVisible())) + return c.y <= g ? c.i : 0; + } + return 0; +} + + +/*! + Returns the y-coordinate of \a item in the list view's coordinate + system. This function is normally much slower than itemAt() but it + works for all items, whereas itemAt() normally works only for + items on the screen. + + This is a thin wrapper around Q3ListViewItem::itemPos(). + + \sa itemAt() itemRect() +*/ + +int Q3ListView::itemPos(const Q3ListViewItem * item) +{ + return item ? item->itemPos() : 0; +} + + +/*! + \property Q3ListView::multiSelection + \brief whether the list view is in multi-selection or extended-selection mode + + If you enable multi-selection, \c Multi, mode, it is possible to + specify whether or not this mode should be extended. \c Extended + means that the user can select multiple items only when pressing + the Shift or Ctrl key at the same time. + + The default selection mode is \c Single. + + \sa selectionMode() +*/ + +void Q3ListView::setMultiSelection(bool enable) +{ + if (!enable) + d->selectionMode = Q3ListView::Single; + else if ( d->selectionMode != Multi && d->selectionMode != Extended) + d->selectionMode = Q3ListView::Multi; +} + +bool Q3ListView::isMultiSelection() const +{ + return d->selectionMode == Q3ListView::Extended || d->selectionMode == Q3ListView::Multi; +} + +/*! + \property Q3ListView::selectionMode + \brief the list view's selection mode + + The mode can be \c Single (the default), \c Extended, \c Multi or + \c NoSelection. + + \sa multiSelection +*/ + +void Q3ListView::setSelectionMode(SelectionMode mode) +{ + if (d->selectionMode == mode) + return; + + if ((d->selectionMode == Multi || d->selectionMode == Extended) && + (mode == Q3ListView::Single || mode == Q3ListView::NoSelection)){ + clearSelection(); + if ((mode == Q3ListView::Single) && currentItem()) + currentItem()->selected = true; + } + + d->selectionMode = mode; +} + +Q3ListView::SelectionMode Q3ListView::selectionMode() const +{ + return d->selectionMode; +} + + +/*! + If \a selected is true the \a item is selected; otherwise it is + unselected. + + If the list view is in \c Single selection mode and \a selected is + true, the currently selected item is unselected and \a item is + made current. Unlike Q3ListViewItem::setSelected(), this function + updates the list view as necessary and emits the + selectionChanged() signals. + + \sa isSelected() setMultiSelection() isMultiSelection() + setCurrentItem(), setSelectionAnchor() +*/ + +void Q3ListView::setSelected(Q3ListViewItem * item, bool selected) +{ + if (!item || item->isSelected() == selected || + !item->isSelectable() || selectionMode() == NoSelection) + return; + + bool emitHighlighted = false; + if (selectionMode() == Single && d->focusItem != item) { + Q3ListViewItem *o = d->focusItem; + if (d->focusItem && d->focusItem->selected) + d->focusItem->setSelected(false); + d->focusItem = item; + if (o) + repaintItem(o); + emitHighlighted = true; + } + + item->setSelected(selected); + + repaintItem(item); + + if (d->selectionMode == Single && selected) + emit selectionChanged(item); + emit selectionChanged(); + + if (emitHighlighted) + emit currentChanged(d->focusItem); +} + +/*! + Sets the selection anchor to \a item, if \a item is selectable. + + The selection anchor is the item that remains selected when + Shift-selecting with either mouse or keyboard in \c Extended + selection mode. + + \sa setSelected() +*/ + +void Q3ListView::setSelectionAnchor(Q3ListViewItem *item) +{ + if (item && item->isSelectable()) + d->selectAnchor = item; +} + +/*! + Sets all the items to be not selected, updates the list view as + necessary, and emits the selectionChanged() signals. Note that for + \c Multi selection list views this function needs to iterate over + \e all items. + + \sa setSelected(), setMultiSelection() +*/ + +void Q3ListView::clearSelection() +{ + selectAll(false); +} + +/*! + If \a select is true, all the items get selected; otherwise all + the items get unselected. This only works in the selection modes \c + Multi and \c Extended. In \c Single and \c NoSelection mode the + selection of the current item is just set to \a select. +*/ + +void Q3ListView::selectAll(bool select) +{ + if (d->selectionMode == Multi || d->selectionMode == Extended) { + bool b = signalsBlocked(); + blockSignals(true); + bool anything = false; + Q3ListViewItemIterator it(this); + while (it.current()) { + Q3ListViewItem *i = it.current(); + if ((bool)i->selected != select) { + i->setSelected(select); + anything = true; + } + ++it; + } + blockSignals(b); + if (anything) { + emit selectionChanged(); + triggerUpdate(); + } + } else if (d->focusItem) { + Q3ListViewItem * i = d->focusItem; + setSelected(i, select); + } +} + +/*! + Inverts the selection. Only works in \c Multi and \c Extended + selection modes. +*/ + +void Q3ListView::invertSelection() +{ + if (d->selectionMode == Single || + d->selectionMode == NoSelection) + return; + + bool b = signalsBlocked(); + blockSignals(true); + Q3ListViewItemIterator it(this); + for (; it.current(); ++it) + it.current()->setSelected(!it.current()->isSelected()); + blockSignals(b); + emit selectionChanged(); + triggerUpdate(); +} + + +/*! + Returns true if the list view item \a i is selected; otherwise + returns false. + + \sa Q3ListViewItem::isSelected() +*/ + +bool Q3ListView::isSelected(const Q3ListViewItem * i) const +{ + return i ? i->isSelected() : false; +} + + +/*! + Returns the selected item if the list view is in \c Single + selection mode and an item is selected. + + If no items are selected or the list view is not in \c Single + selection mode this function returns 0. + + \sa setSelected() setMultiSelection() +*/ + +Q3ListViewItem * Q3ListView::selectedItem() const +{ + if (d->selectionMode != Single) + return 0; + if (d->focusItem && d->focusItem->isSelected()) + return d->focusItem; + return 0; +} + + +/*! + Sets item \a i to be the current item and repaints appropriately + (i.e. highlights the item). The current item is used for keyboard + navigation and focus indication; it is independent of any selected + items, although a selected item can also be the current item. + + \sa currentItem() setSelected() +*/ + +void Q3ListView::setCurrentItem(Q3ListViewItem * i) +{ + if (!i || d->focusItem == i || !i->isEnabled()) + return; + + if (currentItem() && currentItem()->renameBox) { + if (d->defRenameAction == Reject) + currentItem()->cancelRename(currentItem()->renameCol); + else + currentItem()->okRename(currentItem()->renameCol); + } + + Q3ListViewItem * prev = d->focusItem; + d->focusItem = i; + + if (i != prev) { + if (i && d->selectionMode == Single) { + bool changed = false; + if (prev && prev->selected) { + changed = true; + prev->setSelected(false); + } + if (i && !i->selected && d->selectionMode != NoSelection && i->isSelectable()) { + i->setSelected(true); + changed = true; + emit selectionChanged(i); + } + if (changed) + emit selectionChanged(); + } + + if (i) + repaintItem(i); + if (prev) + repaintItem(prev); + emit currentChanged(i); + +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), indexOfItem(i), QAccessible::Focus); +#endif + } +} + + +/*! + Returns the current item, or 0 if there isn't one. + + \sa setCurrentItem() +*/ + +Q3ListViewItem * Q3ListView::currentItem() const +{ + return d->focusItem; +} + + +/*! + Returns the rectangle on the screen that item \a item occupies in + viewport()'s coordinates, or an invalid rectangle if \a item is 0 or + is not currently visible. + + The rectangle returned does not include any children of the + rectangle (i.e. it uses Q3ListViewItem::height(), rather than + Q3ListViewItem::totalHeight()). If you want the rectangle to + include children you can use something like this: + + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 5 + + Note the way it avoids too-high rectangles. totalHeight() can be + much larger than the window system's coordinate system allows. + + itemRect() is comparatively slow. It's best to call it only for + items that are probably on-screen. +*/ + +QRect Q3ListView::itemRect(const Q3ListViewItem * item) const +{ + if (d->drawables.isEmpty()) + buildDrawableList(); + + for (int i = 0; i < d->drawables.size(); ++i) { + const Q3ListViewPrivate::DrawableItem &c = d->drawables.at(i); + if (c.i == item) { + int y = c.y - contentsY(); + if (y + c.i->height() >= 0 && y < ((Q3ListView *)this)->visibleHeight()) { + return QRect(-contentsX(), y, d->h->width(), c.i->height());; + } + } + } + + return QRect(0, 0, -1, -1); +} + + +/*! + \fn void Q3ListView::doubleClicked(Q3ListViewItem *item) + + This signal is emitted whenever an item is double-clicked. It's + emitted on the second button press, not the second button release. + \a item is the list view item on which the user did the + double-click. +*/ + +/*! + \fn void Q3ListView::doubleClicked(Q3ListViewItem *item, const + QPoint& point, int column) + + This signal is emitted when a double-click occurs. It's emitted on + the second button press, not the second button release. The \a + item is the Q3ListViewItem the button was double-clicked on (which + could be 0 if it wasn't double-clicked on an item). The \a point + where the double-click occurred is given in global coordinates. If + an item was double-clicked on, \a column is the column within the + item that was double-clicked; otherwise \a column is -1. + + \warning Do not delete any Q3ListViewItem objects in slots + connected to this signal. +*/ + + +/*! + \fn void Q3ListView::returnPressed(Q3ListViewItem *item) + + This signal is emitted when Enter or Return is pressed. The + \a item parameter is the currentItem(). +*/ + +/*! + \fn void Q3ListView::spacePressed(Q3ListViewItem *item) + + This signal is emitted when Space is pressed. The \a item + parameter is the currentItem(). +*/ + + +/*! + Sets the list view to be sorted by column \a column in ascending + order if \a ascending is true or descending order if it is false. + + If \a column is -1, sorting is disabled and the user cannot sort + columns by clicking on the column headers. If \a column is larger + than the number of columns the user must click on a column + header to sort the list view. +*/ + +void Q3ListView::setSorting(int column, bool ascending) +{ + if (column == -1) + column = Unsorted; + + if (d->sortcolumn == column && d->ascending == ascending) + return; + + d->ascending = ascending; + d->sortcolumn = column; + if (d->sortcolumn != Unsorted && d->sortIndicator) + d->h->setSortIndicator(d->sortcolumn, d->ascending); + else + d->h->setSortIndicator(-1); + + triggerUpdate(); + +#ifndef QT_NO_ACCESSIBILITY + QAccessible::updateAccessibility(viewport(), 0, QAccessible::ObjectReorder); +#endif +} + +/*! + Sets the \a column the list view is sorted by. + + Sorting is triggered by choosing a header section. +*/ + +void Q3ListView::changeSortColumn(int column) +{ + if (isRenaming()) { + if (d->defRenameAction == Q3ListView::Reject) { + currentItem()->cancelRename(currentItem()->renameCol); + } else { + currentItem()->okRename(currentItem()->renameCol); + } + } + if (d->sortcolumn != Unsorted) { + int lcol = d->h->mapToLogical(column); + setSorting(lcol, d->sortcolumn == lcol ? !d->ascending : true); + } +} + +/*! + \internal + Handles renaming when sections are being swapped by the user. +*/ + +void Q3ListView::handleIndexChange() +{ + if (isRenaming()) { + if (d->defRenameAction == Q3ListView::Reject) { + currentItem()->cancelRename(currentItem()->renameCol); + } else { + currentItem()->okRename(currentItem()->renameCol); + } + } + triggerUpdate(); +} + +/*! + Returns the column by which the list view is sorted, or -1 if + sorting is disabled. + + \sa sortOrder() +*/ + +int Q3ListView::sortColumn() const +{ + return d->sortcolumn; +} + +/*! + Sets the sorting column for the list view. + + If \a column is -1, sorting is disabled and the user cannot sort + columns by clicking on the column headers. If \a column is larger + than the number of columns the user must click on a column header + to sort the list view. + + \sa setSorting() +*/ +void Q3ListView::setSortColumn(int column) +{ + setSorting(column, d->ascending); +} + +/*! + Returns the sorting order of the list view items. + + \sa sortColumn() +*/ +Qt::SortOrder Q3ListView::sortOrder() const +{ + if (d->ascending) + return Qt::AscendingOrder; + return Qt::DescendingOrder; +} + +/*! + Sets the sort order for the items in the list view to \a order. + + \sa setSorting() +*/ +void Q3ListView::setSortOrder(Qt::SortOrder order) +{ + setSorting(d->sortcolumn, order == Qt::AscendingOrder ? true : false); +} + +/*! + Sorts the list view using the last sorting configuration (sort + column and ascending/descending). +*/ + +void Q3ListView::sort() +{ + if (d->r) + d->r->sort(); +} + +/*! + \property Q3ListView::itemMargin + \brief the advisory item margin that list items may use + + The item margin defaults to one pixel and is the margin between + the item's edges and the area where it draws its contents. + Q3ListViewItem::paintFocus() draws in the margin. + + \sa Q3ListViewItem::paintCell() +*/ + +void Q3ListView::setItemMargin(int m) +{ + if (d->margin == m) + return; + d->margin = m; + if (isVisible()) { + d->drawables.clear(); + triggerUpdate(); + } +} + +int Q3ListView::itemMargin() const +{ + return d->margin; +} + + +/*! + \fn void Q3ListView::rightButtonClicked(Q3ListViewItem *item, + const QPoint& point, int column) + + This signal is emitted when the right button is clicked. The \a + item is the Q3ListViewItem the button was clicked on (which could + be 0 if it wasn't clicked on an item). The \a point where the + click occurred is given in global coordinates. If an item was + clicked on, \a column is the column within the item that was + clicked; otherwise \a column is -1. +*/ + + +/*! + \fn void Q3ListView::rightButtonPressed (Q3ListViewItem *item, + const QPoint &point, int column) + + This signal is emitted when the right button is pressed. The \a + item is the Q3ListViewItem the button was pressed on (which could + be 0 if it wasn't pressed on an item). The \a point where the + press occurred is given in global coordinates. If an item was + pressed on, \a column is the column within the item that was + pressed; otherwise \a column is -1. +*/ + +/*! + \fn void Q3ListView::contextMenuRequested(Q3ListViewItem *item, const QPoint & pos, int col) + + This signal is emitted when the user invokes a context menu with + the right mouse button or with special system keys. If the + keyboard was used \a item is the current item; if the mouse was + used, \a item is the item under the mouse pointer or 0 if there is + no item under the mouse pointer. If no item is clicked, the column + index emitted is -1. + + \a pos is the position for the context menu in the global + coordinate system. + + \a col is the column on which the user pressed, or -1 if the + signal was triggered by a key event. +*/ + +/*! + \reimp +*/ +void Q3ListView::changeEvent(QEvent *ev) +{ + if(ev->type() == QEvent::StyleChange) { + reconfigureItems(); + } else if(ev->type() == QEvent::ActivationChange) { + if (!isActiveWindow() && d->scrollTimer) + d->scrollTimer->stop(); + if (!palette().isEqual(QPalette::Active, QPalette::Inactive)) + viewport()->update(); + } + Q3ScrollView::changeEvent(ev); + + if (ev->type() == QEvent::ApplicationFontChange || ev->type() == QEvent::FontChange + || ev->type() == QEvent::ApplicationPaletteChange || ev->type() == QEvent::PaletteChange) + reconfigureItems(); +} + +/*! + Ensures that setup() is called for all currently visible items, + and that it will be called for currently invisible items as soon + as their parents are opened. + + (A visible item, here, is an item whose parents are all open. The + item may happen to be off-screen.) + + \sa Q3ListViewItem::setup() +*/ + +void Q3ListView::reconfigureItems() +{ + d->fontMetricsHeight = fontMetrics().height(); + d->minLeftBearing = fontMetrics().minLeftBearing(); + d->minRightBearing = fontMetrics().minRightBearing(); + d->ellipsisWidth = fontMetrics().width(QLatin1String("...")) * 2; + d->r->setOpen(false); + d->r->configured = false; + d->r->setOpen(true); +} + +/*! + Ensures that the width mode of column \a c is updated according to + the width of \a item. +*/ + +void Q3ListView::widthChanged(const Q3ListViewItem* item, int c) +{ + if (c >= d->h->count()) + return; + + + QFontMetrics fm = fontMetrics(); + int col = c < 0 ? 0 : c; + while (col == c || (c < 0 && col < d->h->count())) { + if (d->column[col].wmode == Maximum) { + int w = item->width(fm, this, col); + if (showSortIndicator()) { + int tw = d->h->sectionSizeHint( col, fm ).width(); + tw += 40; //add space for the sort indicator + w = qMax(w, tw); + } + if (col == 0) { + int indent = treeStepSize() * item->depth(); + if (rootIsDecorated()) + indent += treeStepSize(); + w += indent; + } + if (w > columnWidth(col) && !d->h->isStretchEnabled() && !d->h->isStretchEnabled(col)) { + d->updateHeader = true; + setColumnWidth(col, w); + } + } + col++; + } +} + +/*! + \property Q3ListView::allColumnsShowFocus + \brief whether items should show keyboard focus using all columns + + If this property is true all columns will show focus and selection + states, otherwise only column 0 will show focus. + + The default is false. + + Setting this to true if it's not necessary may cause noticeable + flicker. +*/ + +void Q3ListView::setAllColumnsShowFocus(bool enable) +{ + d->allColumnsShowFocus = enable; +} + +bool Q3ListView::allColumnsShowFocus() const +{ + return d->allColumnsShowFocus; +} + + +/*! + Returns the first item in this Q3ListView. Returns 0 if there is no + first item. + + A list view's items can be traversed using firstChild() + and nextSibling() or using a Q3ListViewItemIterator. + + \sa itemAt() Q3ListViewItem::itemBelow() Q3ListViewItem::itemAbove() +*/ + +Q3ListViewItem * Q3ListView::firstChild() const +{ + if (!d->r) + return 0; + + d->r->enforceSortOrder(); + return d->r->childItem; +} + +/*! + Returns the last item in the list view tree. Returns 0 if there + are no items in the Q3ListView. + + This function is slow because it traverses the entire tree to find + the last item. +*/ + +Q3ListViewItem* Q3ListView::lastItem() const +{ + Q3ListViewItem* item = firstChild(); + if (item) { + while (item->nextSibling() || item->firstChild()) { + if (item->nextSibling()) + item = item->nextSibling(); + else + item = item->firstChild(); + } + } + return item; +} + +/*! + Repaints this item on the screen if it is currently visible. +*/ + +void Q3ListViewItem::repaint() const +{ + Q3ListView *lv = listView(); + if (lv) + lv->repaintItem(this); +} + + +/*! + Repaints \a item on the screen if \a item is currently visible. + Takes care to avoid multiple repaints. +*/ + +void Q3ListView::repaintItem(const Q3ListViewItem * item) const +{ + if (!item) + return; + d->dirtyItemTimer->start(0, true); + d->dirtyItems.append(item); +} + + +struct Q3CheckListItemPrivate +{ + Q3CheckListItemPrivate(): + exclusive(0), + currentState(Q3CheckListItem::Off), + tristate(false) {} + + Q3CheckListItem *exclusive; + Q3CheckListItem::ToggleState currentState; + QHash<Q3CheckListItem *, Q3CheckListItem::ToggleState> statesDict; + bool tristate; +}; + + +/*! + \class Q3CheckListItem + \brief The Q3CheckListItem class provides checkable list view items. + + \compat + + Q3CheckListItems are used in \l{Q3ListView}s to provide + \l{Q3ListViewItem}s that are checkboxes, radio buttons or + controllers. + + Checkbox and controller check list items may be inserted at any + level in a list view. Radio button check list items must be + children of a controller check list item. + + The item can be checked or unchecked with setOn(). Its type can be + retrieved with type() and its text retrieved with text(). + + \img qlistviewitems.png List View Items + + \sa Q3ListViewItem Q3ListView +*/ + +/*! + \enum Q3CheckListItem::Type + + This enum type specifies a Q3CheckListItem's type: + + \value RadioButton + \value CheckBox + \value RadioButtonController + \value CheckBoxController + \omitvalue Controller +*/ + +/*! + \enum Q3CheckListItem::ToggleState + + This enum specifies a Q3CheckListItem's toggle state. + + \value Off + \value NoChange + \value On +*/ + + +/*! + Constructs a checkable item with parent \a parent, text \a text + and of type \a tt. Note that a \c RadioButton must be the child of a + \c RadioButtonController, otherwise it will not toggle. +*/ +Q3CheckListItem::Q3CheckListItem(Q3CheckListItem *parent, const QString &text, + Type tt) + : Q3ListViewItem(parent, text, QString()) +{ + myType = tt; + init(); + if (myType == RadioButton) { + if (parent->type() != RadioButtonController) + qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be " + "child of a controller"); + else + d->exclusive = parent; + } +} + +/*! + Constructs a checkable item with parent \a parent, which is after + \a after in the parent's list of children, and with text \a text + and of type \a tt. Note that a \c RadioButton must be the child of + a \c RadioButtonController, otherwise it will not toggle. +*/ +Q3CheckListItem::Q3CheckListItem(Q3CheckListItem *parent, Q3ListViewItem *after, + const QString &text, Type tt) + : Q3ListViewItem(parent, after, text) +{ + myType = tt; + init(); + if (myType == RadioButton) { + if (parent->type() != RadioButtonController) + qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be " + "child of a controller"); + else + d->exclusive = parent; + } +} + +/*! + Constructs a checkable item with parent \a parent, text \a text + and of type \a tt. Note that this item must \e not be a \c + RadioButton. Radio buttons must be children of a \c + RadioButtonController. +*/ +Q3CheckListItem::Q3CheckListItem(Q3ListViewItem *parent, const QString &text, + Type tt) + : Q3ListViewItem(parent, text, QString()) +{ + myType = tt; + if (myType == RadioButton) { + qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be " + "child of a Q3CheckListItem"); + } + init(); +} + +/*! + Constructs a checkable item with parent \a parent, which is after + \a after in the parent's list of children, with text \a text and + of type \a tt. Note that this item must \e not be a \c + RadioButton. Radio buttons must be children of a \c + RadioButtonController. +*/ +Q3CheckListItem::Q3CheckListItem(Q3ListViewItem *parent, Q3ListViewItem *after, + const QString &text, Type tt) + : Q3ListViewItem(parent, after, text) +{ + myType = tt; + if (myType == RadioButton) { + qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be " + "child of a Q3CheckListItem"); + } + init(); +} + + +/*! + Constructs a checkable item with parent \a parent, text \a text + and of type \a tt. Note that \a tt must \e not be \c RadioButton. + Radio buttons must be children of a \c RadioButtonController. +*/ +Q3CheckListItem::Q3CheckListItem(Q3ListView *parent, const QString &text, + Type tt) + : Q3ListViewItem(parent, text) +{ + myType = tt; + if (tt == RadioButton) + qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be " + "child of a Q3CheckListItem"); + init(); +} + +/*! + Constructs a checkable item with parent \a parent, which is after + \a after in the parent's list of children, with text \a text and + of type \a tt. Note that \a tt must \e not be \c RadioButton. + Radio buttons must be children of a \c RadioButtonController. +*/ +Q3CheckListItem::Q3CheckListItem(Q3ListView *parent, Q3ListViewItem *after, + const QString &text, Type tt) + : Q3ListViewItem(parent, after, text) +{ + myType = tt; + if (tt == RadioButton) + qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be " + "child of a Q3CheckListItem"); + init(); +} + + +/* \reimp */ + +int Q3CheckListItem::rtti() const +{ + return RTTI; +} + +/*! + Constructs a \c RadioButtonController item with parent \a parent, + text \a text and pixmap \a p. +*/ +Q3CheckListItem::Q3CheckListItem(Q3ListView *parent, const QString &text, + const QPixmap & p) + : Q3ListViewItem(parent, text) +{ + myType = RadioButtonController; + setPixmap(0, p); + init(); +} + +/*! + Constructs a \c RadioButtonController item with parent \a parent, + text \a text and pixmap \a p. +*/ +Q3CheckListItem::Q3CheckListItem(Q3ListViewItem *parent, const QString &text, + const QPixmap & p) + : Q3ListViewItem(parent, text) +{ + myType = RadioButtonController; + setPixmap(0, p); + init(); +} + +void Q3CheckListItem::init() +{ + d = new Q3CheckListItemPrivate(); + on = false; + // CheckBoxControllers by default have tristate set to true + if (myType == CheckBoxController) + setTristate(true); +} + +/*! + Destroys the item, and all its children to any depth, freeing up + all allocated resources. +*/ +Q3CheckListItem::~Q3CheckListItem() +{ + if (myType == RadioButton + && d->exclusive && d->exclusive->d + && d->exclusive->d->exclusive == this) + d->exclusive->turnOffChild(); + d->exclusive = 0; // so the children won't try to access us. + delete d; + d = 0; +} + +/*! + \fn Q3CheckListItem::Type Q3CheckListItem::type() const + + Returns the type of this item. +*/ + +/*! + \fn bool Q3CheckListItem::isOn() const + + Returns true if the item is toggled on; otherwise returns false. +*/ + +/*! + Sets tristate to \a b if the \c Type is either a \c CheckBoxController or + a \c CheckBox. + + \c CheckBoxControllers are tristate by default. + + \sa state() isTristate() +*/ +void Q3CheckListItem::setTristate(bool b) +{ + if ((myType != CheckBoxController) && (myType != CheckBox)) { + qWarning("Q3CheckListItem::setTristate(), has no effect on RadioButton " + "or RadioButtonController."); + return; + } + d->tristate = b; +} + +/*! + Returns true if the item is tristate; otherwise returns false. + + \sa setTristate() +*/ +bool Q3CheckListItem::isTristate() const +{ + return d->tristate; +} + +/*! + Returns the state of the item. + + \sa Q3CheckListItem::ToggleState +*/ +Q3CheckListItem::ToggleState Q3CheckListItem::state() const +{ + if (!isTristate() && internalState() == NoChange) + return Off; + else + return d->currentState; +} + +/* + Same as the public state() except this one does not mask NoChange into Off + when tristate is disabled. +*/ +Q3CheckListItem::ToggleState Q3CheckListItem::internalState() const +{ + return d->currentState; +} + + + + +/*! + Sets the toggle state of the checklistitem to \a s. \a s can be + \c Off, \c NoChange or \c On. + + Tristate can only be enabled for \c CheckBox or \c CheckBoxController, + therefore the \c NoChange only applies to them. + + Setting the state to \c On or \c Off on a \c CheckBoxController + will recursivly set the states of its children to the same state. + + Setting the state to \c NoChange on a \c CheckBoxController will + make it recursivly recall the previous stored state of its + children. If there was no previous stored state the children are + all set to \c On. +*/ +void Q3CheckListItem::setState(ToggleState s) +{ + if (myType == CheckBoxController && state() == NoChange) + updateStoredState(this); + setState(s, true, true); +} + +/* + Sets the toggle state of the checklistitems. \a update tells if the + controller / parent controller should be aware of these changes, \a store + tells if the parent should store its children if certain conditions arise +*/ +void Q3CheckListItem::setState(ToggleState s, bool update, bool store) +{ + + if (s == internalState()) + return; + + if (myType == CheckBox) { + setCurrentState(s); + stateChange(state()); + if (update && parent() && parent()->rtti() == 1 + && ((Q3CheckListItem*)parent())->type() == CheckBoxController) + ((Q3CheckListItem*)parent())->updateController(update, store); + } else if (myType == CheckBoxController) { + if (s == NoChange && childCount()) { + restoreState(this); + } else { + Q3ListViewItem *item = firstChild(); + int childCount = 0; + while(item) { + if (item->rtti() == 1 && + (((Q3CheckListItem*)item)->type() == CheckBox || + ((Q3CheckListItem*)item)->type() == CheckBoxController)) { + Q3CheckListItem *checkItem = (Q3CheckListItem*)item; + checkItem->setState(s, false, false); + childCount++; + } + item = item->nextSibling(); + } + if (update) { + if (childCount > 0) { + ToggleState oldState = internalState(); + updateController(false, false); + if (oldState != internalState() && + parent() && parent()->rtti() == 1 && + ((Q3CheckListItem*)parent())->type() == CheckBoxController) + ((Q3CheckListItem*)parent())->updateController(update, store); + + updateController(update, store); + } else { + // if there are no children we simply set the CheckBoxController and update its parent + setCurrentState(s); + stateChange(state()); + if (parent() && parent()->rtti() == 1 + && ((Q3CheckListItem*)parent())->type() == CheckBoxController) + ((Q3CheckListItem*)parent())->updateController(update, store); + } + } else { + setCurrentState(s); + stateChange(state()); + } + + } + } else if (myType == RadioButton) { + if (s == On) { + if (d->exclusive && d->exclusive->d->exclusive != this) + d->exclusive->turnOffChild(); + setCurrentState(s); + if (d->exclusive) + d->exclusive->d->exclusive = this; + } else { + if (d->exclusive && d->exclusive->d->exclusive == this) + d->exclusive->d->exclusive = 0; + setCurrentState(Off); + } + stateChange(state()); + } + repaint(); +} + +/* + this function is needed because we need to update "on" every time we + update d->currentState. In order to retain binary compatibility the + inline function isOn() needs the "on" bool ### should be changed in + ver 4 +*/ +void Q3CheckListItem::setCurrentState(ToggleState s) +{ + ToggleState old = d->currentState; + d->currentState = s; + if (d->currentState == On) + on = true; + else + on = false; + +#ifndef QT_NO_ACCESSIBILITY + if (old != d->currentState && listView()) + QAccessible::updateAccessibility(listView()->viewport(), indexOfItem(this), QAccessible::StateChanged); +#else + Q_UNUSED(old); +#endif +} + + + +/* + updates the internally stored state of this item for the parent (key) +*/ +void Q3CheckListItem::setStoredState(ToggleState newState, Q3CheckListItem *key) +{ + if (myType == CheckBox || myType == CheckBoxController) + d->statesDict[key] = newState; +} + +/* + Returns the stored state for this item for the given key. + If the key is not found it returns Off. +*/ +Q3CheckListItem::ToggleState Q3CheckListItem::storedState(Q3CheckListItem *key) const +{ + QHash<Q3CheckListItem *, Q3CheckListItem::ToggleState>::Iterator it = d->statesDict.find(key); + if (it != d->statesDict.end()) + return it.value(); + else + return Off; +} + + +/*! + \fn QString Q3CheckListItem::text() const + + Returns the item's text. +*/ + + +/*! + If this is a \c RadioButtonController that has \c RadioButton + children, turn off the child that is on. +*/ +void Q3CheckListItem::turnOffChild() +{ + if (myType == RadioButtonController && d->exclusive) + d->exclusive->setOn(false); +} + +/*! + Toggle check box or set radio button to on. +*/ +void Q3CheckListItem::activate() +{ + Q3ListView * lv = listView(); + + if ((lv && !lv->isEnabled()) || !isEnabled()) + return; + + QPoint pos; + int boxsize = lv->style()->pixelMetric(QStyle::PM_CheckListButtonSize, 0, lv); + if (activatedPos(pos)) { + bool parentControl = false; + if (parent() && parent()->rtti() == 1 && + ((Q3CheckListItem*) parent())->type() == RadioButtonController) + parentControl = true; + + int x = parentControl ? 0 : 3; + int align = lv->columnAlignment(0); + int marg = lv->itemMargin(); + int y = 0; + + if (align & Qt::AlignVCenter) + y = ((height() - boxsize) / 2) + marg; + else + y = (lv->fontMetrics().height() + 2 + marg - boxsize) / 2; + + QRect r(x, y, boxsize-3, boxsize-3); + // columns might have been swapped + r.moveBy(lv->header()->sectionPos(0), 0); + if (!r.contains(pos)) + return; + } + if ((myType == CheckBox) || (myType == CheckBoxController)) { + lv->d->startEdit = FALSE; + switch (internalState()) { + case On: + setState(Off); + break; + case Off: + if ( (!isTristate() && myType == CheckBox) || + (myType == CheckBoxController && !childCount()) ) { + setState(On); + } else { + setState(NoChange); + if (myType == CheckBoxController && internalState() != NoChange) + setState(On); + } + break; + case NoChange: + setState(On); + break; + } + ignoreDoubleClick(); + } else if (myType == RadioButton) { + setOn(true); + ignoreDoubleClick(); + } +} + +/*! + Sets the button on if \a b is true, otherwise sets it off. + Maintains radio button exclusivity. +*/ +void Q3CheckListItem::setOn(bool b ) +{ + if (b) + setState(On , true, true); + else + setState(Off , true, true); +} + + +/*! + \fn void Q3CheckListItem::stateChange(bool b) + + This virtual function is called when the item changes its state. + \a b is true if the state is \c On; otherwise the state is \c Off. + \c NoChange (if tristate is enabled and the type is either \c + CheckBox or \c CheckBoxController) reports the same as \c Off, so + use state() to determine if the state is actually \c Off or \c + NoChange. +*/ +void Q3CheckListItem::stateChange(bool) +{ +} + +/* + Calls the public virtual function if the state is changed to either On, NoChange or Off. + NoChange reports the same as Off - ### should be fixed in ver4 +*/ +void Q3CheckListItem::stateChange(ToggleState s) +{ + stateChange(s == On); +} + +/* + sets the state of the CheckBox and CheckBoxController back to + previous stored state +*/ +void Q3CheckListItem::restoreState(Q3CheckListItem *key, int depth) +{ + switch (type()) { + case CheckBox: + setCurrentState(storedState(key)); + stateChange(state()); + repaint(); + break; + case CheckBoxController: { + Q3ListViewItem *item = firstChild(); + int childCount = 0; + while (item) { + // recursively calling restoreState for children of type CheckBox and CheckBoxController + if (item->rtti() == 1 && + (((Q3CheckListItem*)item)->type() == CheckBox || + ((Q3CheckListItem*)item)->type() == CheckBoxController)) { + ((Q3CheckListItem*)item)->restoreState(key , depth+1); + childCount++; + } + item = item->nextSibling(); + } + if (childCount > 0) { + if (depth == 0) + updateController(true); + else + updateController(false); + } else { + // if there are no children we retrieve the CheckBoxController state directly. + setState(storedState(key), true, false); + } + } + break; + default: + break; + } +} + + +/* + Checks the childrens state and updates the controllers state + if necessary. If the controllers state change, then his parent again is + called to update itself. +*/ +void Q3CheckListItem::updateController(bool update , bool store) +{ + if (myType != CheckBoxController) + return; + + Q3CheckListItem *controller = 0; + // checks if this CheckBoxController has another CheckBoxController as parent + if (parent() && parent()->rtti() == 1 + && ((Q3CheckListItem*)parent())->type() == CheckBoxController) + controller = (Q3CheckListItem*)parent(); + + ToggleState theState = Off; + bool first = true; + Q3ListViewItem *item = firstChild(); + while(item && theState != NoChange) { + if (item->rtti() == 1 && + (((Q3CheckListItem*)item)->type() == CheckBox || + ((Q3CheckListItem*)item)->type() == CheckBoxController)) { + Q3CheckListItem *checkItem = (Q3CheckListItem*)item; + if (first) { + theState = checkItem->internalState(); + first = false; + } else { + if (checkItem->internalState() == NoChange || + theState != checkItem->internalState()) + theState = NoChange; + else + theState = checkItem->internalState(); + } + } + item = item->nextSibling(); + } + if (internalState() != theState) { + setCurrentState(theState); + if (store && (internalState() == On || internalState() == Off)) + updateStoredState(this); + stateChange(state()); + if (update && controller) { + controller->updateController(update, store); + } + repaint(); + } +} + + +/* + Makes all the children CheckBoxes update their storedState +*/ +void Q3CheckListItem::updateStoredState(Q3CheckListItem *key) +{ + if (myType != CheckBoxController) + return; + + Q3ListViewItem *item = firstChild(); + while(item) { + if (item->rtti() == 1) { + Q3CheckListItem *checkItem = (Q3CheckListItem*)item; + if (checkItem->type() == CheckBox) + checkItem->setStoredState(checkItem->internalState(), key); + else if (checkItem->type() == CheckBoxController) + checkItem->updateStoredState(key); + } + item = item->nextSibling(); + } + // this state is only needed if the CheckBoxController has no CheckBox / CheckBoxController children. + setStoredState(internalState() , key); +} + + +/*! + \reimp +*/ +void Q3CheckListItem::setup() +{ + Q3ListViewItem::setup(); + int h = height(); + Q3ListView *lv = listView(); + if (lv) + h = qMax(lv->style()->pixelMetric(QStyle::PM_CheckListButtonSize, 0, lv), + h); + h = qMax(h, QApplication::globalStrut().height()); + setHeight(h); +} + +/*! + \reimp +*/ + +int Q3CheckListItem::width(const QFontMetrics& fm, const Q3ListView* lv, int column) const +{ + int r = Q3ListViewItem::width(fm, lv, column); + if (column == 0) { + r += lv->itemMargin(); + if (myType == RadioButtonController && pixmap(0)) { + // r += 0; + } else { + r += lv->style()->pixelMetric(QStyle::PM_CheckListButtonSize, 0, lv) + 4; + } + } + return qMax(r, QApplication::globalStrut().width()); +} + +/*! + Paints the item using the painter \a p and the color group \a cg. + The item is in column \a column, has width \a width and has + alignment \a align. (See \l Qt::Alignment for valid alignments.) +*/ +void Q3CheckListItem::paintCell(QPainter * p, const QColorGroup & cg, + int column, int width, int align) +{ + if (!p) + return; + + Q3ListView *lv = listView(); + if (!lv) + return; + + const QPalette::ColorRole crole = lv->backgroundRole(); + if (cg.brush(crole) != lv->palette().brush(cg.currentColorGroup(), crole)) + p->fillRect(0, 0, width, height(), cg.brush(crole)); + else + lv->paintEmptyArea(p, QRect(0, 0, width, height())); + + if (column != 0) { + // The rest is text, or for subclasses to change. + Q3ListViewItem::paintCell(p, cg, column, width, align); + return; + } + + bool parentControl = false; + if (parent() && parent()->rtti() == 1 && + ((Q3CheckListItem*) parent())->type() == RadioButtonController) + parentControl = true; + + QFontMetrics fm(lv->fontMetrics()); + int boxsize = lv->style()->pixelMetric(myType == RadioButtonController ? QStyle::PM_CheckListControllerSize : + QStyle::PM_CheckListButtonSize, 0, lv); + int marg = lv->itemMargin(); + int r = marg; + + // Draw controller / check box / radio button --------------------- + QStyle::State styleflags = QStyle::State_None; + if (internalState() == On) { + styleflags |= QStyle::State_On; + } else if (internalState() == NoChange) { + if (myType == CheckBoxController && !isTristate()) + styleflags |= QStyle::State_Off; + else + styleflags |= QStyle::State_NoChange; + } else { + styleflags |= QStyle::State_Off; + } + if (isSelected()) + styleflags |= QStyle::State_Selected; + if (isEnabled() && lv->isEnabled()) + styleflags |= QStyle::State_Enabled; + if (lv->window()->isActiveWindow()) + styleflags |= QStyle::State_Active; + + if (myType == RadioButtonController) { + int x = 0; + if(!parentControl) + x += 3; + if (!pixmap(0)) { + QStyleOptionQ3ListView opt = getStyleOption(lv, this); + opt.rect.setRect(x, 0, boxsize, fm.height() + 2 + marg); + opt.palette = cg; + opt.state = styleflags; + lv->style()->drawPrimitive(QStyle::PE_Q3CheckListController, &opt, p, lv); + r += boxsize + 4; + } + } else { + Q_ASSERT(lv); //### + int x = 0; + int y = 0; + if (!parentControl) + x += 3; + if (align & Qt::AlignVCenter) + y = ((height() - boxsize) / 2) + marg; + else + y = (fm.height() + 2 + marg - boxsize) / 2; + + QStyleOptionQ3ListView opt = getStyleOption(lv, this); + opt.rect.setRect(x, y, boxsize, fm.height() + 2 + marg); + opt.palette = cg; + opt.state = styleflags; + lv->style()->drawPrimitive((myType == CheckBox || myType == CheckBoxController) + ? QStyle::PE_Q3CheckListIndicator + : QStyle::PE_Q3CheckListExclusiveIndicator, &opt, p, lv); + r += boxsize + 4; + } + + // Draw text ---------------------------------------------------- + p->translate(r, 0); + p->setPen(QPen(cg.text())); + Q3ListViewItem::paintCell(p, cg, column, width - r, align); +} + +/*! + Draws the focus rectangle \a r using the color group \a cg on the + painter \a p. +*/ +void Q3CheckListItem::paintFocus(QPainter *p, const QColorGroup & cg, + const QRect & r) +{ + bool intersect = true; + Q3ListView *lv = listView(); + if (lv && lv->header()->mapToActual(0) != 0) { + int xdepth = lv->treeStepSize() * (depth() + (lv->rootIsDecorated() ? 1 : 0)) + lv->itemMargin(); + int p = lv->header()->cellPos(lv->header()->mapToActual(0)); + xdepth += p; + intersect = r.intersects(QRect(p, r.y(), xdepth - p + 1, r.height())); + } + bool parentControl = false; + if (parent() && parent()->rtti() == 1 && + ((Q3CheckListItem*) parent())->type() == RadioButtonController) + parentControl = true; + if (myType != RadioButtonController && intersect && + (lv->rootIsDecorated() || myType == RadioButton || + (myType == CheckBox && parentControl))) { + QRect rect; + int boxsize = lv->style()->pixelMetric(QStyle::PM_CheckListButtonSize, 0, lv); + if (lv->columnAlignment(0) == Qt::AlignCenter) { + QFontMetrics fm(lv->font()); + int bx = (lv->columnWidth(0) - (boxsize + fm.width(text())))/2 + boxsize; + if (bx < 0) bx = 0; + rect.setRect(r.x() + bx + 5, r.y(), r.width() - bx - 5, + r.height()); + } else + rect.setRect(r.x() + boxsize + 5, r.y(), r.width() - boxsize - 5, + r.height()); + Q3ListViewItem::paintFocus(p, cg, rect); + } else { + Q3ListViewItem::paintFocus(p, cg, r); + } +} + +/*! + \reimp +*/ +QSize Q3ListView::sizeHint() const +{ + if (cachedSizeHint().isValid()) + return cachedSizeHint(); + + ensurePolished(); + + if (!isVisible() && d->drawables.isEmpty()) + // force the column widths to sanity, if possible + buildDrawableList(); + + QSize s(d->h->sizeHint()); + if (verticalScrollBar()->isVisible()) + s.setWidth(s.width() + style()->pixelMetric(QStyle::PM_ScrollBarExtent)); + s += QSize(frameWidth()*2,frameWidth()*2); + Q3ListViewItem * l = d->r; + while(l && !l->height()) + l = l->childItem ? l->childItem : l->siblingItem; + + if (l && l->height()) + s.setHeight(s.height() + 10 * l->height()); + else + s.setHeight(s.height() + 140); + + if (s.width() > s.height() * 3) + s.setHeight(s.width() / 3); + else if (s.width() *3 < s.height()) + s.setHeight(s.width() * 3); + + setCachedSizeHint(s); + + return s; +} + + +/*! + \reimp +*/ + +QSize Q3ListView::minimumSizeHint() const +{ + return Q3ScrollView::minimumSizeHint(); +} + + +/*! + Sets \a item to be open if \a open is true and \a item is + expandable, and to be closed if \a open is false. Repaints + accordingly. + + \sa Q3ListViewItem::setOpen() Q3ListViewItem::setExpandable() +*/ + +void Q3ListView::setOpen(Q3ListViewItem * item, bool open) +{ + if (!item || + item->isOpen() == open || + (open && !item->childCount() && !item->isExpandable())) + return; + + Q3ListViewItem* nextParent = 0; + if (open) + nextParent = item->itemBelow(); + + item->setOpen(open); + + if (open) { + Q3ListViewItem* lastChild = item; + Q3ListViewItem* tmp; + while (true) { + tmp = lastChild->itemBelow(); + if (!tmp || tmp == nextParent) + break; + lastChild = tmp; + } + ensureItemVisible(lastChild); + ensureItemVisible(item); + } + buildDrawableList(); + + int i = 0; + for (; i < d->drawables.size(); ++i) { + const Q3ListViewPrivate::DrawableItem &c = d->drawables.at(i); + if(c.i == item) + break; + } + + if (i < d->drawables.size()) { + d->dirtyItemTimer->start(0, true); + for (; i < d->drawables.size(); ++i) { + const Q3ListViewPrivate::DrawableItem &c = d->drawables.at(i); + d->dirtyItems.append(c.i); + } + } +} + + +/*! + Returns true if this list view item has children \e and they are + not explicitly hidden; otherwise returns false. + + Identical to \a{item}->isOpen(). Provided for completeness. + + \sa setOpen() +*/ + +bool Q3ListView::isOpen(const Q3ListViewItem * item) const +{ + return item->isOpen(); +} + + +/*! + \property Q3ListView::rootIsDecorated + \brief whether the list view shows open/close signs on root items + + Open/close signs are small \bold{+} or \bold{-} symbols in windows + style, or arrows in Motif style. The default is false. +*/ + +void Q3ListView::setRootIsDecorated(bool enable) +{ + if (enable != (bool)d->rootIsExpandable) { + d->rootIsExpandable = enable; + if (isVisible()) + triggerUpdate(); + } +} + +bool Q3ListView::rootIsDecorated() const +{ + return d->rootIsExpandable; +} + + +/*! + Ensures that item \a i is visible, scrolling the list view + vertically if necessary and opening (expanding) any parent items + if this is required to show the item. + + \sa itemRect() Q3ScrollView::ensureVisible() +*/ + +void Q3ListView::ensureItemVisible(const Q3ListViewItem * i) +{ + if (!i || !i->isVisible()) + return; + + Q3ListViewItem *parent = i->parent(); + while (parent) { + if (!parent->isOpen()) + parent->setOpen(true); + parent = parent->parent(); + } + + if (d->r->maybeTotalHeight < 0) + updateGeometries(); + int y = itemPos(i); + int h = i->height(); + if (isVisible() && y + h > contentsY() + visibleHeight()) + setContentsPos(contentsX(), y - visibleHeight() + h); + else if (!isVisible() || y < contentsY()) + setContentsPos(contentsX(), y); +} + + +/*! + \fn QString Q3CheckListItem::text(int n) const + + \reimp +*/ + +/*! + Returns the Q3Header object that manages this list view's columns. + Please don't modify the header behind the list view's back. + + You may safely call Q3Header::setClickEnabled(), + Q3Header::setResizeEnabled(), Q3Header::setMovingEnabled(), + Q3Header::hide() and all the const Q3Header functions. +*/ + +Q3Header * Q3ListView::header() const +{ + return d->h; +} + + +/*! + \property Q3ListView::childCount + \brief the number of parentless (top-level) Q3ListViewItem objects in this Q3ListView + + Holds the current number of parentless (top-level) Q3ListViewItem + objects in this Q3ListView. + + \sa Q3ListViewItem::childCount() +*/ + +int Q3ListView::childCount() const +{ + if (d->r) + return d->r->childCount(); + return 0; +} + + +/* + Moves this item to just after \a olderSibling. \a olderSibling and + this object must have the same parent. + + If you need to move an item in the hierarchy use takeItem() and + insertItem(). +*/ + +void Q3ListViewItem::moveToJustAfter(Q3ListViewItem * olderSibling) +{ + if (parentItem && olderSibling && + olderSibling->parentItem == parentItem && olderSibling != this) { + if (parentItem->childItem == this) { + parentItem->childItem = siblingItem; + } else { + Q3ListViewItem * i = parentItem->childItem; + while(i && i->siblingItem != this) + i = i->siblingItem; + if (i) + i->siblingItem = siblingItem; + } + siblingItem = olderSibling->siblingItem; + olderSibling->siblingItem = this; + parentItem->lsc = Unsorted; + } +} + +/*! + Move the item to be after item \a after, which must be one of the + item's siblings. To move an item in the hierarchy, use takeItem() + and insertItem(). + + Note that this function will have no effect if sorting is enabled + in the list view. +*/ + +void Q3ListViewItem::moveItem(Q3ListViewItem *after) +{ + if (!after || after == this) + return; + if (parent() != after->parent()) { + if (parentItem) + parentItem->takeItem(this); + if (after->parentItem) { + int tmpLsc = after->parentItem->lsc; + after->parentItem->insertItem(this); + after->parentItem->lsc = tmpLsc; + } + } + moveToJustAfter(after); + Q3ListView *lv = listView(); + if (lv) + lv->triggerUpdate(); +} + +/* + Recursively sorts items, from the root to this item. + (enforceSortOrder() won't work the other way around, as + documented.) +*/ +void Q3ListViewItem::enforceSortOrderBackToRoot() +{ + if (parentItem) { + parentItem->enforceSortOrderBackToRoot(); + parentItem->enforceSortOrder(); + } +} + +/*! + \reimp +*/ +void Q3ListView::showEvent(QShowEvent *) +{ + d->drawables.clear(); + d->dirtyItems.clear(); + d->dirtyItemTimer->stop(); + d->fullRepaintOnComlumnChange = true; + + updateGeometries(); +} + + +/*! + Returns the y coordinate of this item in the list view's + coordinate system. This function is normally much slower than + Q3ListView::itemAt(), but it works for all items whereas + Q3ListView::itemAt() normally only works for items on the screen. + + \sa Q3ListView::itemAt() Q3ListView::itemRect() Q3ListView::itemPos() +*/ + +int Q3ListViewItem::itemPos() const +{ + QStack<Q3ListViewItem *> s; + Q3ListViewItem * i = (Q3ListViewItem *)this; + while(i) { + s.push(i); + i = i->parentItem; + } + + int a = 0; + Q3ListViewItem * p = 0; + while(s.count()) { + i = s.pop(); + if (p) { + if (!p->configured) { + p->configured = true; + p->setup(); // ### virtual non-const function called in const + } + a += p->height(); + Q3ListViewItem * s = p->firstChild(); + while(s && s != i) { + a += s->totalHeight(); + s = s->nextSibling(); + } + } + p = i; + } + return a; +} + + +/*! + \fn void Q3ListView::removeItem(Q3ListViewItem *item) + + Removes the given \a item. Use takeItem() instead. +*/ + +/*! + Removes item \a i from the list view; \a i must be a top-level + item. The warnings regarding Q3ListViewItem::takeItem() apply to + this function, too. + + \sa insertItem() +*/ +void Q3ListView::takeItem(Q3ListViewItem * i) +{ + if (d->r) + d->r->takeItem(i); +} + + +void Q3ListView::openFocusItem() +{ + d->autoopenTimer->stop(); + if (d->focusItem && !d->focusItem->isOpen()) { + d->focusItem->setOpen(true); + d->focusItem->repaint(); + } +} + +static const int autoopenTime = 750; + +#ifndef QT_NO_DRAGANDDROP + +/*! \reimp */ + +void Q3ListView::contentsDragEnterEvent(QDragEnterEvent *e) +{ + d->oldFocusItem = d->focusItem; + Q3ListViewItem *i = d->focusItem; + d->focusItem = itemAt(contentsToViewport(e->pos())); + if (i) + i->repaint(); + if (d->focusItem) { + d->autoopenTimer->start(autoopenTime); + d->focusItem->dragEntered(); + d->focusItem->repaint(); + } + e->accept(); +} + +/*! \reimp */ + +void Q3ListView::contentsDragMoveEvent(QDragMoveEvent *e) +{ + Q3ListViewItem *i = d->focusItem; + d->focusItem = itemAt(contentsToViewport(e->pos())); + if (i) { + if (i != d->focusItem) + i->dragLeft(); + i->repaint(); + } + if (d->focusItem) { + if (i != d->focusItem) { + d->focusItem->dragEntered(); + d->autoopenTimer->stop(); + d->autoopenTimer->start(autoopenTime); + } + d->focusItem->repaint(); + } else { + d->autoopenTimer->stop(); + } + if ((i && i->dropEnabled() && i->acceptDrop(e)) || acceptDrops()) + e->accept(); + else + e->ignore(); +} + +/*! \reimp */ + +void Q3ListView::contentsDragLeaveEvent(QDragLeaveEvent *) +{ + d->autoopenTimer->stop(); + + if (d->focusItem) + d->focusItem->dragLeft(); + + setCurrentItem(d->oldFocusItem); + d->oldFocusItem = 0; +} + +/*! \reimp */ + +void Q3ListView::contentsDropEvent(QDropEvent *e) +{ + d->autoopenTimer->stop(); + + setCurrentItem(d->oldFocusItem); + Q3ListViewItem *i = itemAt(contentsToViewport(e->pos())); + if (i && i->dropEnabled() && i->acceptDrop(e)) { + i->dropped(e); + e->accept(); + } else if (acceptDrops()) { + emit dropped(e); + e->accept(); + } +} + +/*! + If the user presses the mouse on an item and starts moving the + mouse, and the item allow dragging (see + Q3ListViewItem::setDragEnabled()), this function is called to get a + drag object and a drag is started unless dragObject() returns 0. + + By default this function returns 0. You should reimplement it and + create a Q3DragObject depending on the selected items. +*/ + +Q3DragObject *Q3ListView::dragObject() +{ + return 0; +} + +/*! + Starts a drag. +*/ + +void Q3ListView::startDrag() +{ + if (!d->startDragItem) + return; + + d->startDragItem = 0; + d->buttonDown = false; + + Q3DragObject *drag = dragObject(); + if (!drag) + return; + + drag->drag(); +} + +#endif // QT_NO_DRAGANDDROP + +/*! + \property Q3ListView::defaultRenameAction + \brief What action to perform when the editor loses focus during renaming + + If this property is \c Accept, and the user renames an item and + the editor loses focus (without the user pressing Enter), the + item will still be renamed. If the property's value is \c Reject, + the item will not be renamed unless the user presses Enter. The + default is \c Reject. +*/ + +void Q3ListView::setDefaultRenameAction(RenameAction a) +{ + d->defRenameAction = a; +} + +Q3ListView::RenameAction Q3ListView::defaultRenameAction() const +{ + return d->defRenameAction; +} + +/*! + Returns true if an item is being renamed; otherwise returns false. +*/ + +bool Q3ListView::isRenaming() const +{ + return currentItem() && currentItem()->renameBox; +} + +/********************************************************************** + * + * Class Q3ListViewItemIterator + * + **********************************************************************/ + + +/*! + \class Q3ListViewItemIterator + \brief The Q3ListViewItemIterator class provides an iterator for collections of Q3ListViewItems. + + \compat + + Construct an instance of a Q3ListViewItemIterator, with either a + Q3ListView* or a Q3ListViewItem* as argument, to operate on the tree + of Q3ListViewItems, starting from the argument. + + A Q3ListViewItemIterator iterates over all the items from its + starting point. This means that it always makes the first child of + the current item the new current item. If there is no child, the + next sibling becomes the new current item; and if there is no next + sibling, the next sibling of the parent becomes current. + + The following example creates a list of all the items that have + been selected by the user, storing pointers to the items in a + QList: + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 6 + + An alternative approach is to use an \c IteratorFlag: + \snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 7 + + A Q3ListViewItemIterator provides a convenient and easy way to + traverse a hierarchical Q3ListView. + + Multiple Q3ListViewItemIterators can operate on the tree of + Q3ListViewItems. A Q3ListView knows about all iterators operating on + its Q3ListViewItems. So when a Q3ListViewItem gets removed all + iterators that point to this item are updated and point to the + following item if possible, otherwise to a valid item before the + current one or to 0. Note however that deleting the parent item of + an item that an iterator points to is not safe. + + \sa Q3ListView, Q3ListViewItem +*/ + +/*! + \enum Q3ListViewItemIterator::IteratorFlag + + These flags can be passed to a Q3ListViewItemIterator constructor + (OR-ed together if more than one is used), so that the iterator + will only iterate over items that match the given flags. + + \value Visible + \value Invisible + \value Selected + \value Unselected + \value Selectable + \value NotSelectable + \value DragEnabled + \value DragDisabled + \value DropEnabled + \value DropDisabled + \value Expandable + \value NotExpandable + \value Checked + \value NotChecked +*/ + +/*! + Constructs an empty iterator. +*/ + +Q3ListViewItemIterator::Q3ListViewItemIterator() + : curr(0), listView(0), flags(0) +{ +} + +/*! + Constructs an iterator for the Q3ListView that contains the \a + item. The current iterator item is set to point to the \a item. +*/ + +Q3ListViewItemIterator::Q3ListViewItemIterator(Q3ListViewItem *item) + : curr(item), listView(0), flags(0) +{ + if (item) { + item->enforceSortOrderBackToRoot(); + listView = item->listView(); + } + if (listView) + listView->d->iterators.append(this); +} + +/*! + Constructs an iterator for the Q3ListView that contains the \a item + using the flags \a iteratorFlags. The current iterator item is set + to point to \a item or the next matching item if \a item doesn't + match the flags. + + \sa Q3ListViewItemIterator::IteratorFlag +*/ + +Q3ListViewItemIterator::Q3ListViewItemIterator(Q3ListViewItem *item, int iteratorFlags) + : curr(item), listView(0), flags(iteratorFlags) +{ + // go to next matching item if the current don't match + if (curr && !matchesFlags(curr)) + ++(*this); + + if (curr) { + curr->enforceSortOrderBackToRoot(); + listView = curr->listView(); + } + if (listView) + listView->d->iterators.append(this); +} + + +/*! + Constructs an iterator for the same Q3ListView as \a it. The + current iterator item is set to point on the current item of \a + it. +*/ + +Q3ListViewItemIterator::Q3ListViewItemIterator(const Q3ListViewItemIterator& it) + : curr(it.curr), listView(it.listView), flags(it.flags) +{ + if (listView) + listView->d->iterators.append(this); +} + +/*! + Constructs an iterator for the Q3ListView \a lv. The current + iterator item is set to point on the first child (Q3ListViewItem) + of \a lv. +*/ + +Q3ListViewItemIterator::Q3ListViewItemIterator(Q3ListView *lv) + : curr(lv->firstChild()), listView(lv), flags(0) +{ + if (listView) + listView->d->iterators.append(this); +} + +/*! + Constructs an iterator for the Q3ListView \a lv with the flags \a + iteratorFlags. The current iterator item is set to point on the + first child (Q3ListViewItem) of \a lv that matches the flags. + + \sa Q3ListViewItemIterator::IteratorFlag +*/ + +Q3ListViewItemIterator::Q3ListViewItemIterator(Q3ListView *lv, int iteratorFlags) + : curr (lv->firstChild()), listView(lv), flags(iteratorFlags) +{ + if (listView) + listView->d->iterators.append(this); + if (!matchesFlags(curr)) + ++(*this); +} + + + +/*! + Assignment. Makes a copy of \a it and returns a reference to its + iterator. +*/ + +Q3ListViewItemIterator &Q3ListViewItemIterator::operator=(const Q3ListViewItemIterator &it) +{ + if (listView) + listView->d->iterators.removeAll(this); + + listView = it.listView; + curr = it.curr; + flags = it.flags; + if (listView) + listView->d->iterators.append(this); + + // go to next matching item if the current don't match + if (curr && !matchesFlags(curr)) + ++(*this); + + return *this; +} + +/*! + Destroys the iterator. +*/ + +Q3ListViewItemIterator::~Q3ListViewItemIterator() +{ + if (listView) + listView->d->iterators.removeAll(this); +} + +/*! + Prefix ++. Makes the next item the new current item and returns + it. Returns 0 if the current item is the last item or the + Q3ListView is 0. +*/ + +Q3ListViewItemIterator &Q3ListViewItemIterator::operator++() +{ + if (!curr) + return *this; + + Q3ListViewItem *item = curr->firstChild(); + if (!item) { + while ((item = curr->nextSibling()) == 0 ) { + curr = curr->parent(); + if (curr == 0) + break; + } + } + curr = item; + // if the next one doesn't match the flags we try one more ahead + if (curr && !matchesFlags(curr)) + ++(*this); + return *this; +} + +/*! + \overload + + Postfix ++. Makes the next item the new current item and returns + the item that \e was the current item. +*/ + +const Q3ListViewItemIterator Q3ListViewItemIterator::operator++(int) +{ + Q3ListViewItemIterator oldValue = *this; + ++(*this); + return oldValue; +} + +/*! + Sets the current item to the item \a j positions after the current + item. If that item is beyond the last item, the current item is + set to 0. Returns the current item. +*/ + +Q3ListViewItemIterator &Q3ListViewItemIterator::operator+=(int j) +{ + while (curr && j--) + ++(*this); + + return *this; +} + +/*! + Prefix --. Makes the previous item the new current item and + returns it. Returns 0 if the current item is the first item or the + Q3ListView is 0. +*/ + +Q3ListViewItemIterator &Q3ListViewItemIterator::operator--() +{ + if (!curr) + return *this; + + if (!curr->parent()) { + // we are in the first depth + if (curr->listView()) { + if (curr->listView()->firstChild() != curr) { + // go the previous sibling + Q3ListViewItem *i = curr->listView()->firstChild(); + while (i && i->siblingItem != curr) + i = i->siblingItem; + + curr = i; + + if (i && i->firstChild()) { + // go to the last child of this item + Q3ListViewItemIterator it(curr->firstChild()); + for (; it.current() && it.current()->parent(); ++it) + curr = it.current(); + } + + if (curr && !matchesFlags(curr)) + --(*this); + + return *this; + } else { + //we are already the first child of the list view, so it's over + curr = 0; + return *this; + } + } else + return *this; + } else { + Q3ListViewItem *parent = curr->parent(); + + if (curr != parent->firstChild()) { + // go to the previous sibling + Q3ListViewItem *i = parent->firstChild(); + while (i && i->siblingItem != curr) + i = i->siblingItem; + + curr = i; + + if (i && i->firstChild()) { + // go to the last child of this item + Q3ListViewItemIterator it(curr->firstChild()); + for (; it.current() && it.current()->parent() != parent; ++it) + curr = it.current(); + } + + if (curr && !matchesFlags(curr)) + --(*this); + + return *this; + } else { + // make our parent the current item + curr = parent; + + if (curr && !matchesFlags(curr)) + --(*this); + + return *this; + } + } +} + +/*! + \overload + + Postfix --. Makes the previous item the new current item and + returns the item that \e was the current item. +*/ + +const Q3ListViewItemIterator Q3ListViewItemIterator::operator--(int) +{ + Q3ListViewItemIterator oldValue = *this; + --(*this); + return oldValue; +} + +/*! + Sets the current item to the item \a j positions before the + current item. If that item is before the first item, the current + item is set to 0. Returns the current item. +*/ + +Q3ListViewItemIterator &Q3ListViewItemIterator::operator-=(int j) +{ + while (curr && j--) + --(*this); + + return *this; +} + +/*! + Dereference operator. Returns a reference to the current item. The + same as current(). +*/ + +Q3ListViewItem* Q3ListViewItemIterator::operator*() +{ + if (curr != 0 && !matchesFlags(curr)) + qWarning("Q3ListViewItemIterator::operator*() curr out of sync"); + return curr; +} + +/*! + Returns iterator's current item. +*/ + +Q3ListViewItem *Q3ListViewItemIterator::current() const +{ + if (curr != 0 && !matchesFlags(curr)) + qWarning("Q3ListViewItemIterator::current() curr out of sync"); + return curr; +} + +/* + This function is called to notify the iterator that the current + item has been deleted, and sets the current item point to another + (valid) item or 0. +*/ + +void Q3ListViewItemIterator::currentRemoved() +{ + if (!curr) return; + + if (curr->parent()) + curr = curr->parent(); + else if (curr->nextSibling()) + curr = curr->nextSibling(); + else if (listView && listView->firstChild() && + listView->firstChild() != curr) + curr = listView->firstChild(); + else + curr = 0; +} + +/* + returns true if the item \a item matches all of the flags set for the iterator +*/ +bool Q3ListViewItemIterator::matchesFlags(const Q3ListViewItem *item) const +{ + if (!item) + return false; + + if (flags == 0) + return true; + + if (flags & Visible && !item->isVisible()) + return false; + if (flags & Invisible && item->isVisible()) + return false; + if (flags & Selected && !item->isSelected()) + return false; + if (flags & Unselected && item->isSelected()) + return false; + if (flags & Selectable && !item->isSelectable()) + return false; + if (flags & NotSelectable && item->isSelectable()) + return false; + if (flags & DragEnabled && !item->dragEnabled()) + return false; + if (flags & DragDisabled && item->dragEnabled()) + return false; + if (flags & DropEnabled && !item->dropEnabled()) + return false; + if (flags & DropDisabled && item->dropEnabled()) + return false; + if (flags & Expandable && !item->isExpandable()) + return false; + if (flags & NotExpandable && item->isExpandable()) + return false; + if (flags & Checked && !isChecked(item)) + return false; + if (flags & NotChecked && isChecked(item)) + return false; + + return true; +} + +/* + we want the iterator to check Q3CheckListItems as well, so we provide this convenience function + that checks if the rtti() is 1 which means Q3CheckListItem and if isOn is true, returns false otherwise. +*/ +bool Q3ListViewItemIterator::isChecked(const Q3ListViewItem *item) const +{ + if (item->rtti() == 1) + return ((const Q3CheckListItem*)item)->isOn(); + else return false; +} + +void Q3ListView::handleItemChange(Q3ListViewItem *old, bool shift, bool control) +{ + if (d->selectionMode == Single) { + // nothing + } else if (d->selectionMode == Extended) { + if (shift) { + selectRange(d->selectAnchor ? d->selectAnchor : old, + d->focusItem, false, true, (d->selectAnchor && !control) ? true : false); + } else if (!control) { + bool block = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(block); + setSelected(d->focusItem, true); + } + } else if (d->selectionMode == Multi) { + if (shift) + selectRange(old, d->focusItem, true, false); + } +} + +void Q3ListView::startRename() +{ + if (!currentItem()) + return; + currentItem()->startRename(d->pressedColumn); + d->buttonDown = false; +} + +/* unselects items from to, including children, returns true if any items were unselected */ +bool Q3ListView::clearRange(Q3ListViewItem *from, Q3ListViewItem *to, bool includeFirst) +{ + if (!from || !to) + return false; + + // Swap + if (from->itemPos() > to->itemPos()) { + Q3ListViewItem *temp = from; + from = to; + to = temp; + } + + // Start on second? + if (!includeFirst) { + Q3ListViewItem *below = (from == to) ? from : from->itemBelow(); + if (below) + from = below; + } + + // Clear items <from, to> + bool changed = false; + + Q3ListViewItemIterator it(from); + while (it.current()) { + if (it.current()->isSelected()) { + it.current()->setSelected(false); + changed = true; + } + if (it.current() == to) + break; + ++it; + } + + // NOTE! This function does _not_ emit + // any signals about selection changed + return changed; +} + +void Q3ListView::selectRange(Q3ListViewItem *from, Q3ListViewItem *to, bool invert, bool includeFirst, bool clearSel) +{ + if (!from || !to) + return; + if (from == to && !includeFirst) + return; + bool swap = false; + if (to == from->itemAbove()) + swap = true; + if (!swap && from != to && from != to->itemAbove()) { + Q3ListViewItemIterator it(from); + bool found = false; + for (; it.current(); ++it) { + if (it.current() == to) { + found = true; + break; + } + } + if (!found) + swap = true; + } + if (swap) { + Q3ListViewItem *i = from; + from = to; + to = i; + if (!includeFirst) + to = to->itemAbove(); + } else { + if (!includeFirst) + from = from->itemBelow(); + } + + bool changed = false; + if (clearSel) { + Q3ListViewItemIterator it(firstChild()); + for (; it.current(); ++it) { + if (it.current()->selected) { + it.current()->setSelected(false); + changed = true; + } + } + it = Q3ListViewItemIterator(to); + for (; it.current(); ++it) { + if (it.current()->selected) { + it.current()->setSelected(false); + changed = true; + } + } + } + + for (Q3ListViewItem *i = from; i; i = i->itemBelow()) { + if (!invert) { + if (!i->selected && i->isSelectable()) { + i->setSelected(true); + changed = true; + } + } else { + bool sel = !i->selected; + if (((bool)i->selected != sel && sel && i->isSelectable()) || !sel) { + i->setSelected(sel); + changed = true; + } + } + if (i == to) + break; + } + if (changed) { + triggerUpdate(); + emit selectionChanged(); + } +} + +/* clears selection from anchor to old, selects from anchor to new, does not emit selectionChanged on change */ +bool Q3ListView::selectRange(Q3ListViewItem *newItem, Q3ListViewItem *oldItem, Q3ListViewItem *anchorItem) +{ + if (!newItem || !oldItem || !anchorItem) + return false; + + int anchorPos = anchorItem ? anchorItem->itemPos() : 0, + oldPos = oldItem ? oldItem->itemPos() : 0, + newPos = newItem->itemPos(); + Q3ListViewItem *top=0, *bottom=0; + if (anchorPos > newPos) { + top = newItem; + bottom = anchorItem; + } else { + top = anchorItem; + bottom = newItem; + } + + // removes the subControls of the old selection that will no longer be selected + bool changed = false; + int topPos = top ? top->itemPos() : 0, + bottomPos = bottom ? bottom->itemPos() : 0; + if (!(oldPos > topPos && oldPos < bottomPos)) { + if (oldPos < topPos) + changed = clearRange(oldItem, top); + else + changed = clearRange(bottom, oldItem); + } + + // selects the new (not already selected) items + Q3ListViewItemIterator lit(top); + for (; lit.current(); ++lit) { + if ((bool)lit.current()->selected != d->select) { + lit.current()->setSelected(d->select); + changed = true; + } + // Include bottom, then break + if (lit.current() == bottom) + break; + } + + return changed; +} + + +/*! + Finds the first list view item in column \a column, that matches + \a text and returns the item, or returns 0 of no such item could + be found. Pass OR-ed together \l ComparisonFlags values + in the \a compare flag, to control how the matching is performed. + The default comparison mode is case-sensitive, exact match. +*/ + +Q3ListViewItem *Q3ListView::findItem(const QString& text, int column, + ComparisonFlags compare) const +{ + if (text.isEmpty() && !(compare & ExactMatch)) + return 0; + + if (compare == Qt::CaseSensitive || compare == 0) + compare |= ExactMatch; + + QString itmtxt; + QString comtxt = text; + if (!(compare & Qt::CaseSensitive)) + comtxt = comtxt.toLower(); + + Q3ListViewItemIterator it(d->focusItem ? d->focusItem : firstChild()); + Q3ListViewItem *sentinel = 0; + Q3ListViewItem *item; + Q3ListViewItem *beginsWithItem = 0; + Q3ListViewItem *endsWithItem = 0; + Q3ListViewItem *containsItem = 0; + + for (int pass = 0; pass < 2; pass++) { + while ((item = it.current()) != sentinel) { + itmtxt = item->text(column); + if (!(compare & CaseSensitive)) + itmtxt = itmtxt.toLower(); + + if ((compare & ExactMatch)==ExactMatch && itmtxt == comtxt) + return item; + if (compare & BeginsWith && !beginsWithItem && itmtxt.startsWith(comtxt)) + beginsWithItem = containsItem = item; + if (compare & EndsWith && !endsWithItem && itmtxt.endsWith(comtxt)) + endsWithItem = containsItem = item; + if ((compare & ExactMatch)==0 && !containsItem && itmtxt.contains(comtxt)) + containsItem = item; + ++it; + } + + it = Q3ListViewItemIterator(firstChild()); + sentinel = d->focusItem ? d->focusItem : firstChild(); + } + + // Obey the priorities + if (beginsWithItem) + return beginsWithItem; + else if (endsWithItem) + return endsWithItem; + else if (containsItem) + return containsItem; + return 0; +} + +/*! + Hides the column specified at \a column. This is a convenience + function that calls setColumnWidth(column, 0). + + Note: The user may still be able to resize the hidden column using + the header handles. To prevent this, call setResizeEnabled(false, + \a column) on the list views header. + + \sa setColumnWidth() +*/ + +void Q3ListView::hideColumn(int column) +{ + setColumnWidth(column, 0); +} + +/*! Adjusts the column \a col to its preferred width */ + +void Q3ListView::adjustColumn(int col) +{ + if (col < 0 || col > (int)d->column.count() - 1 || d->h->isStretchEnabled(col)) + return; + + int oldw = d->h->sectionSize(col); + + int w = d->h->sectionSizeHint(col, fontMetrics()).width(); + if (d->h->iconSet(col)) + w += d->h->iconSet(col)->pixmap().width(); + w = qMax(w, 20); + QFontMetrics fm(fontMetrics()); + Q3ListViewItem* item = firstChild(); + int rootDepth = rootIsDecorated() ? treeStepSize() : 0; + while (item) { + int iw = item->width(fm, this, col); + if (0 == col) + iw += itemMargin() + rootDepth + item->depth()*treeStepSize() - 1; + w = qMax(w, iw); + item = item->itemBelow(); + } + w = qMax(w, QApplication::globalStrut().width()); + + d->h->adjustHeaderSize(oldw - w); + if (oldw != w) { + d->fullRepaintOnComlumnChange = true; + d->h->resizeSection(col, w); + emit d->h->sizeChange(col, oldw, w); + } +} + +/*! + \enum Q3ListView::StringComparisonMode + + This enum type is used to set the string comparison mode when + searching for an item. We'll refer to the string being searched + as the 'target' string. + + \value CaseSensitive The strings must match case sensitively. + \value ExactMatch The target and search strings must match exactly. + \value BeginsWith The target string begins with the search string. + \value EndsWith The target string ends with the search string. + \value Contains The target string contains the search string. + + If you OR these flags together (excluding \c CaseSensitive), the + search criteria be applied in the following order: \c ExactMatch, + \c BeginsWith, \c EndsWith, \c Contains. + + Matching is case-insensitive unless \c CaseSensitive is set. \c + CaseSensitive can be OR-ed with any combination of the other + flags. + + \sa ComparisonFlags +*/ + +/*! + \typedef Q3ListView::ComparisonFlags + + This typedef is used in Q3ListView's API for values that are OR'd + combinations of \l StringComparisonMode values. + + \sa StringComparisonMode +*/ + +QT_END_NAMESPACE + +#endif // QT_NO_LISTVIEW diff --git a/src/qt3support/itemviews/q3listview.h b/src/qt3support/itemviews/q3listview.h new file mode 100644 index 0000000..8a1ceda --- /dev/null +++ b/src/qt3support/itemviews/q3listview.h @@ -0,0 +1,609 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3LISTVIEW_H +#define Q3LISTVIEW_H + +#include <Qt3Support/q3scrollview.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_LISTVIEW + +class QPixmap; +class QFont; +class Q3Header; +class QIcon; + +class Q3ListView; +struct Q3ListViewPrivate; +struct Q3CheckListItemPrivate; +class Q3ListViewItemIterator; +struct Q3ListViewItemIteratorPrivate; +class Q3DragObject; +class QMimeSource; +class QLineEdit; +class Q3ListViewToolTip; + +class Q_COMPAT_EXPORT Q3ListViewItem +{ + friend class Q3ListViewItemIterator; + friend class Q3ListViewToolTip; + +public: + Q3ListViewItem(Q3ListView * parent); + Q3ListViewItem(Q3ListViewItem * parent); + Q3ListViewItem(Q3ListView * parent, Q3ListViewItem * after); + Q3ListViewItem(Q3ListViewItem * parent, Q3ListViewItem * after); + + Q3ListViewItem(Q3ListView * parent, + const QString&, const QString& = QString(), + const QString& = QString(), const QString& = QString(), + const QString& = QString(), const QString& = QString(), + const QString& = QString(), const QString& = QString()); + Q3ListViewItem(Q3ListViewItem * parent, + const QString&, const QString& = QString(), + const QString& = QString(), const QString& = QString(), + const QString& = QString(), const QString& = QString(), + const QString& = QString(), const QString& = QString()); + + Q3ListViewItem(Q3ListView * parent, Q3ListViewItem * after, + const QString&, const QString& = QString(), + const QString& = QString(), const QString& = QString(), + const QString& = QString(), const QString& = QString(), + const QString& = QString(), const QString& = QString()); + Q3ListViewItem(Q3ListViewItem * parent, Q3ListViewItem * after, + const QString&, const QString& = QString(), + const QString& = QString(), const QString& = QString(), + const QString& = QString(), const QString& = QString(), + const QString& = QString(), const QString& = QString()); + virtual ~Q3ListViewItem(); + + virtual void insertItem(Q3ListViewItem *); + virtual void takeItem(Q3ListViewItem *); + virtual void removeItem(Q3ListViewItem *item) { takeItem(item); } + + int height() const; + virtual void invalidateHeight(); + int totalHeight() const; + virtual int width(const QFontMetrics&, + const Q3ListView*, int column) const; + void widthChanged(int column=-1) const; + int depth() const; + + virtual void setText(int, const QString &); + virtual QString text(int) const; + + virtual void setPixmap(int, const QPixmap &); + virtual const QPixmap * pixmap(int) const; + + virtual QString key(int, bool) const; + virtual int compare(Q3ListViewItem *i, int col, bool) const; + virtual void sortChildItems(int, bool); + + int childCount() const { return nChildren; } + + bool isOpen() const { return open; } + virtual void setOpen(bool); + virtual void setup(); + + virtual void setSelected(bool); + bool isSelected() const { return selected; } + + virtual void paintCell(QPainter *, const QColorGroup & cg, + int column, int width, int alignment); + virtual void paintBranches(QPainter * p, const QColorGroup & cg, int w, int y, int h); + virtual void paintFocus(QPainter *, const QColorGroup & cg, const QRect & r); + + Q3ListViewItem * firstChild() const; + Q3ListViewItem * nextSibling() const { return siblingItem; } + Q3ListViewItem * parent() const; + + Q3ListViewItem * itemAbove() const; + Q3ListViewItem * itemBelow() const; + + int itemPos() const; + + Q3ListView *listView() const; + + virtual void setSelectable(bool enable); + bool isSelectable() const { return selectable && enabled; } + + virtual void setExpandable(bool); + bool isExpandable() const { return expandable; } + + void repaint() const; + + virtual void sort(); + void moveItem(Q3ListViewItem *after); + + virtual void setDragEnabled(bool allow); + virtual void setDropEnabled(bool allow); + bool dragEnabled() const; + bool dropEnabled() const; + virtual bool acceptDrop(const QMimeSource *mime) const; + + void setVisible(bool b); + bool isVisible() const; + + virtual void setRenameEnabled(int col, bool b); + bool renameEnabled(int col) const; + virtual void startRename(int col); + + virtual void setEnabled(bool b); + bool isEnabled() const; + + virtual int rtti() const; + enum { RTTI = 0 }; + + virtual void setMultiLinesEnabled(bool b); + bool multiLinesEnabled() const; + +protected: + virtual void enforceSortOrder() const; + virtual void setHeight(int); + virtual void activate(); + + bool activatedPos(QPoint &); +#ifndef QT_NO_DRAGANDDROP + virtual void dropped(QDropEvent *e); +#endif + virtual void dragEntered(); + virtual void dragLeft(); + virtual void okRename(int col); + virtual void cancelRename(int col); + + void ignoreDoubleClick(); + +private: + void init(); + void moveToJustAfter(Q3ListViewItem *); + void enforceSortOrderBackToRoot(); + void removeRenameBox(); + + int ownHeight; + int maybeTotalHeight; + int nChildren; + + uint lsc: 14; + uint lso: 1; + uint open : 1; + uint selected : 1; + uint selectable: 1; + uint configured: 1; + uint expandable: 1; + uint is_root: 1; + uint allow_drag : 1; + uint allow_drop : 1; + uint visible : 1; + uint enabled : 1; + uint mlenabled : 1; + + Q3ListViewItem * parentItem; + Q3ListViewItem * siblingItem; + Q3ListViewItem * childItem; + QLineEdit *renameBox; + int renameCol; + + void * columns; + + friend class Q3ListView; +}; + +class Q3CheckListItem; + +class Q_COMPAT_EXPORT Q3ListView : public Q3ScrollView +{ + friend class Q3ListViewItemIterator; + friend class Q3ListViewItem; + friend class Q3CheckListItem; + friend class Q3ListViewToolTip; + + Q_OBJECT + Q_ENUMS(SelectionMode ResizeMode RenameAction) + Q_PROPERTY(int columns READ columns) + Q_PROPERTY(bool multiSelection READ isMultiSelection WRITE setMultiSelection DESIGNABLE false) + Q_PROPERTY(SelectionMode selectionMode READ selectionMode WRITE setSelectionMode) + Q_PROPERTY(int childCount READ childCount) + Q_PROPERTY(bool allColumnsShowFocus READ allColumnsShowFocus WRITE setAllColumnsShowFocus) + Q_PROPERTY(bool showSortIndicator READ showSortIndicator WRITE setShowSortIndicator) + Q_PROPERTY(int itemMargin READ itemMargin WRITE setItemMargin) + Q_PROPERTY(bool rootIsDecorated READ rootIsDecorated WRITE setRootIsDecorated) + Q_PROPERTY(bool showToolTips READ showToolTips WRITE setShowToolTips) + Q_PROPERTY(ResizeMode resizeMode READ resizeMode WRITE setResizeMode) + Q_PROPERTY(int treeStepSize READ treeStepSize WRITE setTreeStepSize) + Q_PROPERTY(RenameAction defaultRenameAction READ defaultRenameAction WRITE setDefaultRenameAction) + +public: + Q3ListView(QWidget* parent=0, const char* name=0, Qt::WindowFlags f = 0); + ~Q3ListView(); + + int treeStepSize() const; + virtual void setTreeStepSize(int); + + virtual void insertItem(Q3ListViewItem *); + virtual void takeItem(Q3ListViewItem *); + virtual void removeItem(Q3ListViewItem *item) { takeItem(item); } + + Q3Header * header() const; + + virtual int addColumn(const QString &label, int size = -1); + virtual int addColumn(const QIcon& icon, const QString &label, int size = -1); + virtual void removeColumn(int index); + virtual void setColumnText(int column, const QString &label); + virtual void setColumnText(int column, const QIcon& icon, const QString &label); + QString columnText(int column) const; + virtual void setColumnWidth(int column, int width); + int columnWidth(int column) const; + enum WidthMode { Manual, Maximum }; + virtual void setColumnWidthMode(int column, WidthMode); + WidthMode columnWidthMode(int column) const; + int columns() const; + + virtual void setColumnAlignment(int, int); + int columnAlignment(int) const; + + void show(); + + QVariant inputMethodQuery(Qt::InputMethodQuery query) const; + Q3ListViewItem * itemAt(const QPoint & screenPos) const; + QRect itemRect(const Q3ListViewItem *) const; + int itemPos(const Q3ListViewItem *); + + void ensureItemVisible(const Q3ListViewItem *); + + void repaintItem(const Q3ListViewItem *) const; + + virtual void setMultiSelection(bool enable); + bool isMultiSelection() const; + + enum SelectionMode { Single, Multi, Extended, NoSelection }; + void setSelectionMode(SelectionMode mode); + SelectionMode selectionMode() const; + + virtual void clearSelection(); + virtual void setSelected(Q3ListViewItem *, bool); + void setSelectionAnchor(Q3ListViewItem *); + bool isSelected(const Q3ListViewItem *) const; + Q3ListViewItem * selectedItem() const; + virtual void setOpen(Q3ListViewItem *, bool); + bool isOpen(const Q3ListViewItem *) const; + + virtual void setCurrentItem(Q3ListViewItem *); + Q3ListViewItem * currentItem() const; + + Q3ListViewItem * firstChild() const; + Q3ListViewItem * lastItem() const; + + int childCount() const; + + virtual void setAllColumnsShowFocus(bool); + bool allColumnsShowFocus() const; + + virtual void setItemMargin(int); + int itemMargin() const; + + virtual void setRootIsDecorated(bool); + bool rootIsDecorated() const; + + virtual void setSorting(int column, bool ascending = true); + int sortColumn() const; + void setSortColumn(int column); + Qt::SortOrder sortOrder() const; + void setSortOrder(Qt::SortOrder order); + virtual void sort(); + + bool eventFilter(QObject * o, QEvent *); + + QSize sizeHint() const; + QSize minimumSizeHint() const; + + virtual void setShowSortIndicator(bool show); + bool showSortIndicator() const; + virtual void setShowToolTips(bool b); + bool showToolTips() const; + + enum ResizeMode { NoColumn, AllColumns, LastColumn }; + virtual void setResizeMode(ResizeMode m); + ResizeMode resizeMode() const; + + enum StringComparisonMode { + CaseSensitive = 0x00001, // 0 0001 + BeginsWith = 0x00002, // 0 0010 + EndsWith = 0x00004, // 0 0100 + Contains = 0x00008, // 0 1000 + ExactMatch = 0x00010 // 1 0000 + }; + typedef uint ComparisonFlags; + Q3ListViewItem * findItem(const QString& text, int column, + ComparisonFlags = ExactMatch | Qt::CaseSensitive ) const; + + enum RenameAction { Accept, Reject }; + virtual void setDefaultRenameAction(RenameAction a); + RenameAction defaultRenameAction() const; + bool isRenaming() const; + + void hideColumn(int column); + +public Q_SLOTS: + virtual void clear(); + virtual void invertSelection(); + virtual void selectAll(bool select); + void triggerUpdate(); + void setContentsPos(int x, int y); + void adjustColumn(int col); + +Q_SIGNALS: + void selectionChanged(); + void selectionChanged(Q3ListViewItem *); + void currentChanged(Q3ListViewItem *); + void clicked(Q3ListViewItem *); + void clicked(Q3ListViewItem *, const QPoint &, int); + void pressed(Q3ListViewItem *); + void pressed(Q3ListViewItem *, const QPoint &, int); + + void doubleClicked(Q3ListViewItem *); + void doubleClicked(Q3ListViewItem *, const QPoint&, int); + void returnPressed(Q3ListViewItem *); + void spacePressed(Q3ListViewItem *); + void rightButtonClicked(Q3ListViewItem *, const QPoint&, int); + void rightButtonPressed(Q3ListViewItem *, const QPoint&, int); + void mouseButtonPressed(int, Q3ListViewItem *, const QPoint& , int); + void mouseButtonClicked(int, Q3ListViewItem *, const QPoint&, int); + + void contextMenuRequested(Q3ListViewItem *, const QPoint &, int); + + void onItem(Q3ListViewItem *item); + void onViewport(); + + void expanded(Q3ListViewItem *item); + void collapsed(Q3ListViewItem *item); +#ifndef QT_NO_DRAGANDDROP + void dropped(QDropEvent *e); +#endif + void itemRenamed(Q3ListViewItem *item, int col, const QString &); + void itemRenamed(Q3ListViewItem *item, int col ); + +protected: + void contentsMousePressEvent(QMouseEvent * e); + void contentsMouseReleaseEvent(QMouseEvent * e); + void contentsMouseMoveEvent(QMouseEvent * e); + void contentsMouseDoubleClickEvent(QMouseEvent * e); + void contentsContextMenuEvent(QContextMenuEvent * e); +#ifndef QT_NO_DRAGANDDROP + void contentsDragEnterEvent(QDragEnterEvent *e); + void contentsDragMoveEvent(QDragMoveEvent *e); + void contentsDragLeaveEvent(QDragLeaveEvent *e); + void contentsDropEvent(QDropEvent *e); + virtual Q3DragObject *dragObject(); + virtual void startDrag(); +#endif + + void focusInEvent(QFocusEvent * e); + void focusOutEvent(QFocusEvent * e); + + void keyPressEvent(QKeyEvent *e); + + void resizeEvent(QResizeEvent *e); + void viewportResizeEvent(QResizeEvent *e); + + void showEvent(QShowEvent *); + + void drawContentsOffset(QPainter *, int ox, int oy, + int cx, int cy, int cw, int ch); + + virtual void paintEmptyArea(QPainter *, const QRect &); + void changeEvent(QEvent *); + +protected Q_SLOTS: + void updateContents(); + void doAutoScroll(); + +private Q_SLOTS: + void changeSortColumn(int); + void handleIndexChange(); + void updateDirtyItems(); + void makeVisible(); + void handleSizeChange(int, int, int); + void startRename(); + void openFocusItem(); + +private: + Q_DISABLE_COPY(Q3ListView) + + void contentsMousePressEventEx(QMouseEvent * e); + void contentsMouseReleaseEventEx(QMouseEvent * e); + void init(); + void updateGeometries(); + void buildDrawableList() const; + void reconfigureItems(); + void widthChanged(const Q3ListViewItem*, int c); + void handleItemChange(Q3ListViewItem *old, bool shift, bool control); + void selectRange(Q3ListViewItem *from, Q3ListViewItem *to, bool invert, bool includeFirst, bool clearSel = false); + bool selectRange(Q3ListViewItem *newItem, Q3ListViewItem *oldItem, Q3ListViewItem *anchorItem); + bool clearRange(Q3ListViewItem *from, Q3ListViewItem *to, bool includeFirst = true); + void doAutoScroll(const QPoint &cursorPos); + + Q3ListViewPrivate *d; +}; + + +class Q_COMPAT_EXPORT Q3CheckListItem : public Q3ListViewItem +{ +public: + enum Type { RadioButton, + CheckBox, + Controller, + RadioButtonController=Controller, + CheckBoxController }; + + enum ToggleState { Off, NoChange, On }; + + Q3CheckListItem(Q3CheckListItem *parent, const QString &text, + Type = RadioButtonController); + Q3CheckListItem(Q3CheckListItem *parent, Q3ListViewItem *after, + const QString &text, Type = RadioButtonController); + Q3CheckListItem(Q3ListViewItem *parent, const QString &text, + Type = RadioButtonController); + Q3CheckListItem(Q3ListViewItem *parent, Q3ListViewItem *after, + const QString &text, Type = RadioButtonController); + Q3CheckListItem(Q3ListView *parent, const QString &text, + Type = RadioButtonController); + Q3CheckListItem(Q3ListView *parent, Q3ListViewItem *after, + const QString &text, Type = RadioButtonController); + Q3CheckListItem(Q3ListViewItem *parent, const QString &text, + const QPixmap &); + Q3CheckListItem(Q3ListView *parent, const QString &text, + const QPixmap &); + ~Q3CheckListItem(); + + void paintCell(QPainter *, const QColorGroup & cg, + int column, int width, int alignment); + virtual void paintFocus(QPainter *, const QColorGroup &cg, + const QRect & r); + int width(const QFontMetrics&, const Q3ListView*, int column) const; + void setup(); + + virtual void setOn(bool); + bool isOn() const { return on; } + Type type() const { return myType; } + QString text() const { return Q3ListViewItem::text(0); } + QString text(int n) const { return Q3ListViewItem::text(n); } + + void setTristate(bool); + bool isTristate() const; + ToggleState state() const; + void setState(ToggleState s); + + int rtti() const; + enum { RTTI = 1 }; + +protected: + void activate(); + void turnOffChild(); + virtual void stateChange(bool); + +private: + void init(); + ToggleState internalState() const; + void setStoredState(ToggleState newState, Q3CheckListItem *key); + ToggleState storedState(Q3CheckListItem *key) const; + void stateChange(ToggleState s); + void restoreState(Q3CheckListItem *key, int depth = 0); + void updateController(bool update = true , bool store = false); + void updateStoredState(Q3CheckListItem *key); + void setState(ToggleState s, bool update, bool store); + void setCurrentState(ToggleState s); + + Type myType; + bool on; + Q3CheckListItemPrivate *d; +}; + +class Q_COMPAT_EXPORT Q3ListViewItemIterator +{ + friend struct Q3ListViewPrivate; + friend class Q3ListView; + friend class Q3ListViewItem; + +public: + enum IteratorFlag { + Visible = 0x00000001, + Invisible = 0x00000002, + Selected = 0x00000004, + Unselected = 0x00000008, + Selectable = 0x00000010, + NotSelectable = 0x00000020, + DragEnabled = 0x00000040, + DragDisabled = 0x00000080, + DropEnabled = 0x00000100, + DropDisabled = 0x00000200, + Expandable = 0x00000400, + NotExpandable = 0x00000800, + Checked = 0x00001000, + NotChecked = 0x00002000 + }; + + Q3ListViewItemIterator(); + Q3ListViewItemIterator(Q3ListViewItem *item); + Q3ListViewItemIterator(Q3ListViewItem *item, int iteratorFlags); + + Q3ListViewItemIterator(const Q3ListViewItemIterator &it); + Q3ListViewItemIterator(Q3ListView *lv); + Q3ListViewItemIterator(Q3ListView *lv, int iteratorFlags); + + Q3ListViewItemIterator &operator=(const Q3ListViewItemIterator &it); + + ~Q3ListViewItemIterator(); + + Q3ListViewItemIterator &operator++(); + const Q3ListViewItemIterator operator++(int); + Q3ListViewItemIterator &operator+=(int j); + + Q3ListViewItemIterator &operator--(); + const Q3ListViewItemIterator operator--(int); + Q3ListViewItemIterator &operator-=(int j); + + Q3ListViewItem* operator*(); + Q3ListViewItem *current() const; + +private: + Q3ListViewItem *curr; + Q3ListView *listView; + int flags; + + void currentRemoved(); + bool matchesFlags(const Q3ListViewItem*) const; + bool testPair(Q3ListViewItemIterator::IteratorFlag, Q3ListViewItemIterator::IteratorFlag, bool) const; + bool isChecked(const Q3ListViewItem*) const; +}; + +#endif // QT_NO_LISTVIEW + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3LISTVIEW_H diff --git a/src/qt3support/itemviews/q3table.cpp b/src/qt3support/itemviews/q3table.cpp new file mode 100644 index 0000000..658b0ad --- /dev/null +++ b/src/qt3support/itemviews/q3table.cpp @@ -0,0 +1,7333 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@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; + +}; + +#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 + +/*! \reimp */ +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" diff --git a/src/qt3support/itemviews/q3table.h b/src/qt3support/itemviews/q3table.h new file mode 100644 index 0000000..6331ca4 --- /dev/null +++ b/src/qt3support/itemviews/q3table.h @@ -0,0 +1,548 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3TABLE_H +#define Q3TABLE_H + +#include <Qt3Support/q3scrollview.h> +#include <QtGui/qpixmap.h> +#include <Qt3Support/q3ptrvector.h> +#include <Qt3Support/q3header.h> +#include <Qt3Support/q3memarray.h> +#include <Qt3Support/q3ptrlist.h> +#include <Qt3Support/q3shared.h> +#include <Qt3Support/q3intdict.h> +#include <QtCore/qstringlist.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3Support) + +class Q3TableHeader; +class QValidator; +class Q3Table; +class QPaintEvent; +class QTimer; +class QResizeEvent; +class Q3ComboBox; +class QCheckBox; +class Q3DragObject; +class QColorGroup; + +struct Q3TablePrivate; +struct Q3TableHeaderPrivate; + + +class Q_COMPAT_EXPORT Q3TableSelection +{ +public: + Q3TableSelection(); + Q3TableSelection(int start_row, int start_col, int end_row, int end_col); + void init(int row, int col); + void expandTo(int row, int col); + bool operator==(const Q3TableSelection &s) const; + bool operator!=(const Q3TableSelection &s) const { return !(operator==(s)); } + + int topRow() const { return tRow; } + int bottomRow() const { return bRow; } + int leftCol() const { return lCol; } + int rightCol() const { return rCol; } + int anchorRow() const { return aRow; } + int anchorCol() const { return aCol; } + int numRows() const; + int numCols() const; + + bool isActive() const { return active; } + bool isEmpty() const { return numRows() == 0; } + +private: + uint active : 1; + uint inited : 1; + int tRow, lCol, bRow, rCol; + int aRow, aCol; +}; + +class Q_COMPAT_EXPORT Q3TableItem +{ + friend class Q3Table; + +public: + enum EditType { Never, OnTyping, WhenCurrent, Always }; + + Q3TableItem(Q3Table *table, EditType et); + Q3TableItem(Q3Table *table, EditType et, const QString &text); + Q3TableItem(Q3Table *table, EditType et, const QString &text, + const QPixmap &p); + virtual ~Q3TableItem(); + + virtual QPixmap pixmap() const; + virtual QString text() const; + virtual void setPixmap(const QPixmap &p); + virtual void setText(const QString &t); + Q3Table *table() const { return t; } + + virtual int alignment() const; + virtual void setWordWrap(bool b); + bool wordWrap() const; + + EditType editType() const; + virtual QWidget *createEditor() const; + virtual void setContentFromEditor(QWidget *w); + virtual void setReplaceable(bool); + bool isReplaceable() const; + + virtual QString key() const; + virtual QSize sizeHint() const; + + virtual void setSpan(int rs, int cs); + int rowSpan() const; + int colSpan() const; + + virtual void setRow(int r); + virtual void setCol(int c); + int row() const; + int col() const; + + virtual void paint(QPainter *p, const QColorGroup &cg, + const QRect &cr, bool selected); + + void updateEditor(int oldRow, int oldCol); + + virtual void setEnabled(bool b); + bool isEnabled() const; + + virtual int rtti() const; + static int RTTI; + +private: + QString txt; + QPixmap pix; + Q3Table *t; + EditType edType; + uint wordwrap : 1; + uint tcha : 1; + uint enabled : 1; + int rw, cl; + int rowspan, colspan; +}; + +class Q_COMPAT_EXPORT Q3ComboTableItem : public Q3TableItem +{ +public: + Q3ComboTableItem(Q3Table *table, const QStringList &list, bool editable = false); + ~Q3ComboTableItem(); + virtual QWidget *createEditor() const; + virtual void setContentFromEditor(QWidget *w); + virtual void paint(QPainter *p, const QColorGroup &cg, + const QRect &cr, bool selected); + virtual void setCurrentItem(int i); + virtual void setCurrentItem(const QString &i); + int currentItem() const; + QString currentText() const; + int count() const; +#if !defined(Q_NO_USING_KEYWORD) + using Q3TableItem::text; +#else + inline QString text() const { return Q3TableItem::text(); } +#endif + QString text(int i) const; + virtual void setEditable(bool b); + bool isEditable() const; + virtual void setStringList(const QStringList &l); + + int rtti() const; + static int RTTI; + + QSize sizeHint() const; + +private: + Q3ComboBox *cb; + QStringList entries; + int current; + bool edit; + static Q3ComboBox *fakeCombo; + static QWidget *fakeComboWidget; + static int fakeRef; + +}; + +class Q_COMPAT_EXPORT Q3CheckTableItem : public Q3TableItem +{ +public: + Q3CheckTableItem(Q3Table *table, const QString &txt); + void setText(const QString &t); + virtual QWidget *createEditor() const; + virtual void setContentFromEditor(QWidget *w); + virtual void paint(QPainter *p, const QColorGroup &cg, + const QRect &cr, bool selected); + virtual void setChecked(bool b); + bool isChecked() const; + + int rtti() const; + static int RTTI; + + QSize sizeHint() const; + +private: + QCheckBox *cb; + bool checked; + +}; + +class Q_COMPAT_EXPORT Q3Table : public Q3ScrollView +{ + Q_OBJECT + Q_ENUMS(SelectionMode FocusStyle) + Q_PROPERTY(int numRows READ numRows WRITE setNumRows) + Q_PROPERTY(int numCols READ numCols WRITE setNumCols) + Q_PROPERTY(bool showGrid READ showGrid WRITE setShowGrid) + Q_PROPERTY(bool rowMovingEnabled READ rowMovingEnabled WRITE setRowMovingEnabled) + Q_PROPERTY(bool columnMovingEnabled READ columnMovingEnabled WRITE setColumnMovingEnabled) + Q_PROPERTY(bool readOnly READ isReadOnly WRITE setReadOnly) + Q_PROPERTY(bool sorting READ sorting WRITE setSorting) + Q_PROPERTY(SelectionMode selectionMode READ selectionMode WRITE setSelectionMode) + Q_PROPERTY(FocusStyle focusStyle READ focusStyle WRITE setFocusStyle) + Q_PROPERTY(int numSelections READ numSelections) + + friend class Q3TableHeader; + friend class Q3ComboTableItem; + friend class Q3CheckTableItem; + friend class Q3TableItem; + +public: + Q3Table(QWidget* parent=0, const char* name=0); + Q3Table(int numRows, int numCols, + QWidget* parent=0, const char* name=0); + ~Q3Table(); + + Q3Header *horizontalHeader() const; + Q3Header *verticalHeader() const; + + enum SelectionMode { Single, Multi, SingleRow, MultiRow, NoSelection }; + virtual void setSelectionMode(SelectionMode mode); + SelectionMode selectionMode() const; + + virtual void setItem(int row, int col, Q3TableItem *item); + virtual void setText(int row, int col, const QString &text); + virtual void setPixmap(int row, int col, const QPixmap &pix); + virtual Q3TableItem *item(int row, int col) const; + virtual QString text(int row, int col) const; + virtual QPixmap pixmap(int row, int col) const; + virtual void clearCell(int row, int col); + + virtual QRect cellGeometry(int row, int col) const; + virtual int columnWidth(int col) const; + virtual int rowHeight(int row) const; + virtual int columnPos(int col) const; + virtual int rowPos(int row) const; + virtual int columnAt(int x) const; + virtual int rowAt(int y) const; + + virtual int numRows() const; + virtual int numCols() const; + + void updateCell(int row, int col); + + bool eventFilter(QObject * o, QEvent *); + + int currentRow() const { return curRow; } + int currentColumn() const { return curCol; } + void ensureCellVisible(int row, int col); + + bool isSelected(int row, int col) const; + bool isRowSelected(int row, bool full = false) const; + bool isColumnSelected(int col, bool full = false) const; + int numSelections() const; + Q3TableSelection selection(int num) const; + virtual int addSelection(const Q3TableSelection &s); + virtual void removeSelection(const Q3TableSelection &s); + virtual void removeSelection(int num); + virtual int currentSelection() const; + + void selectCells(int start_row, int start_col, int end_row, int end_col); + virtual void selectRow(int row); + virtual void selectColumn(int col); + + bool showGrid() const; + + QVariant inputMethodQuery(Qt::InputMethodQuery query) const; + + bool columnMovingEnabled() const; + bool rowMovingEnabled() const; + + virtual void sortColumn(int col, bool ascending = true, + bool wholeRows = false); + bool sorting() const; + + virtual void takeItem(Q3TableItem *i); + + virtual void setCellWidget(int row, int col, QWidget *e); + virtual QWidget *cellWidget(int row, int col) const; + virtual void clearCellWidget(int row, int col); + + virtual QRect cellRect(int row, int col) const; + + virtual void paintCell(QPainter *p, int row, int col, + const QRect &cr, bool selected); + virtual void paintCell(QPainter *p, int row, int col, + const QRect &cr, bool selected, const QColorGroup &cg); + virtual void paintFocus(QPainter *p, const QRect &r); + QSize sizeHint() const; + + bool isReadOnly() const; + bool isRowReadOnly(int row) const; + bool isColumnReadOnly(int col) const; + + void setEnabled(bool b); + + void repaintSelections(); + + enum FocusStyle { FollowStyle, SpreadSheet }; + virtual void setFocusStyle(FocusStyle fs); + FocusStyle focusStyle() const; + + void updateHeaderStates(); + + bool isRowHidden(int row) const; + bool isColumnHidden(int col) const; + bool isColumnStretchable(int col) const; + bool isRowStretchable(int row) const; + bool dragEnabled() const; + +public Q_SLOTS: + virtual void setNumRows(int r); + virtual void setNumCols(int r); + virtual void setShowGrid(bool b); + virtual void hideRow(int row); + virtual void hideColumn(int col); + virtual void showRow(int row); + virtual void showColumn(int col); + + virtual void setColumnWidth(int col, int w); + virtual void setRowHeight(int row, int h); + + virtual void adjustColumn(int col); + virtual void adjustRow(int row); + + virtual void setColumnStretchable(int col, bool stretch); + virtual void setRowStretchable(int row, bool stretch); + virtual void setSorting(bool b); + virtual void swapRows(int row1, int row2, bool swapHeader = false); + virtual void swapColumns(int col1, int col2, bool swapHeader = false); + virtual void swapCells(int row1, int col1, int row2, int col2); + + virtual void setLeftMargin(int m); + virtual void setTopMargin(int m); + virtual void setCurrentCell(int row, int col); + void clearSelection(bool repaint = true); + virtual void setColumnMovingEnabled(bool b); + virtual void setRowMovingEnabled(bool b); + + virtual void setReadOnly(bool b); + virtual void setRowReadOnly(int row, bool ro); + virtual void setColumnReadOnly(int col, bool ro); + + virtual void setDragEnabled(bool b); + + virtual void insertRows(int row, int count = 1); + virtual void insertColumns(int col, int count = 1); + virtual void removeRow(int row); + virtual void removeRows(const Q3MemArray<int> &rows); + virtual void removeColumn(int col); + virtual void removeColumns(const Q3MemArray<int> &cols); + + virtual void editCell(int row, int col, bool replace = false); + + void setRowLabels(const QStringList &labels); + void setColumnLabels(const QStringList &labels); + +protected: + enum EditMode { NotEditing, Editing, Replacing }; + void drawContents(QPainter *p, int cx, int cy, int cw, int ch); + void contentsMousePressEvent(QMouseEvent*); + void contentsMouseMoveEvent(QMouseEvent*); + void contentsMouseDoubleClickEvent(QMouseEvent*); + void contentsMouseReleaseEvent(QMouseEvent*); + void contentsContextMenuEvent(QContextMenuEvent * e); + void keyPressEvent(QKeyEvent*); + void focusInEvent(QFocusEvent*); + void focusOutEvent(QFocusEvent*); + void viewportResizeEvent(QResizeEvent *); + void showEvent(QShowEvent *e); + void paintEvent(QPaintEvent *e); + void setEditMode(EditMode mode, int row, int col); +#ifndef QT_NO_DRAGANDDROP + virtual void contentsDragEnterEvent(QDragEnterEvent *e); + virtual void contentsDragMoveEvent(QDragMoveEvent *e); + virtual void contentsDragLeaveEvent(QDragLeaveEvent *e); + virtual void contentsDropEvent(QDropEvent *e); + virtual Q3DragObject *dragObject(); + virtual void startDrag(); +#endif + + virtual void paintEmptyArea(QPainter *p, int cx, int cy, int cw, int ch); + virtual void activateNextCell(); + virtual QWidget *createEditor(int row, int col, bool initFromCell) const; + virtual void setCellContentFromEditor(int row, int col); + virtual QWidget *beginEdit(int row, int col, bool replace); + virtual void endEdit(int row, int col, bool accept, bool replace); + + virtual void resizeData(int len); + virtual void insertWidget(int row, int col, QWidget *w); + int indexOf(int row, int col) const; + + void windowActivationChange(bool); + bool isEditing() const; + EditMode editMode() const; + int currEditRow() const; + int currEditCol() const; + +protected Q_SLOTS: + virtual void columnWidthChanged(int col); + virtual void rowHeightChanged(int row); + virtual void columnIndexChanged(int section, int fromIndex, int toIndex); + virtual void rowIndexChanged(int section, int fromIndex, int toIndex); + virtual void columnClicked(int col); + +Q_SIGNALS: + void currentChanged(int row, int col); + void clicked(int row, int col, int button, const QPoint &mousePos); + void doubleClicked(int row, int col, int button, const QPoint &mousePos); + void pressed(int row, int col, int button, const QPoint &mousePos); + void selectionChanged(); + void valueChanged(int row, int col); + void contextMenuRequested(int row, int col, const QPoint &pos); +#ifndef QT_NO_DRAGANDDROP + void dropped(QDropEvent *e); +#endif + +private Q_SLOTS: + void doAutoScroll(); + void doValueChanged(); + void updateGeometriesSlot(); + +private: + void contentsMousePressEventEx(QMouseEvent*); + void drawContents(QPainter*); + void updateGeometries(); + void repaintSelections(Q3TableSelection *oldSelection, + Q3TableSelection *newSelection, + bool updateVertical = true, + bool updateHorizontal = true); + QRect rangeGeometry(int topRow, int leftCol, + int bottomRow, int rightCol, bool &optimize); + void fixRow(int &row, int y); + void fixCol(int &col, int x); + + void init(int numRows, int numCols); + QSize tableSize() const; + void repaintCell(int row, int col); + void contentsToViewport2(int x, int y, int& vx, int& vy); + QPoint contentsToViewport2(const QPoint &p); + void viewportToContents2(int vx, int vy, int& x, int& y); + QPoint viewportToContents2(const QPoint &p); + + void updateRowWidgets(int row); + void updateColWidgets(int col); + bool isSelected(int row, int col, bool includeCurrent) const; + void setCurrentCell(int row, int col, bool updateSelections, bool ensureVisible = false); + void fixCell(int &row, int &col, int key); + void delayedUpdateGeometries(); + struct TableWidget + { + TableWidget(QWidget *w, int r, int c) : wid(w), row(r), col (c) {} + QWidget *wid; + int row, col; + }; + void saveContents(Q3PtrVector<Q3TableItem> &tmp, + Q3PtrVector<TableWidget> &tmp2); + void updateHeaderAndResizeContents(Q3TableHeader *header, + int num, int colRow, + int width, bool &updateBefore); + void restoreContents(Q3PtrVector<Q3TableItem> &tmp, + Q3PtrVector<TableWidget> &tmp2); + void finishContentsResze(bool updateBefore); + +private: + Q3PtrVector<Q3TableItem> contents; + Q3PtrVector<QWidget> widgets; + int curRow; + int curCol; + Q3TableHeader *leftHeader, *topHeader; + EditMode edMode; + int editCol, editRow; + Q3PtrList<Q3TableSelection> selections; + Q3TableSelection *currentSel; + QTimer *autoScrollTimer; + int lastSortCol; + bool sGrid : 1; + bool mRows : 1; + bool mCols : 1; + bool asc : 1; + bool doSort : 1; + bool unused : 1; + bool readOnly : 1; + bool shouldClearSelection : 1; + bool dEnabled : 1; + bool context_menu : 1; + bool drawActiveSelection : 1; + bool was_visible : 1; + SelectionMode selMode; + int pressedRow, pressedCol; + Q3TablePrivate *d; + Q3IntDict<int> roRows; + Q3IntDict<int> roCols; + int startDragRow; + int startDragCol; + QPoint dragStartPos; + int oldCurrentRow, oldCurrentCol; + FocusStyle focusStl; + + Q_DISABLE_COPY(Q3Table) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3TABLE_H |