| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the Qt3Support module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** 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. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $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; |
| |
| 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) |
| return; |
| |
| // If there is just one child, just sort its children |
| if (childItem->siblingItem == 0) { |
| if (childItem->isOpen()) |
| childItem->sortChildItems(column, ascending); |
| 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 |