MCL/sf/mw/qt: comparison src/qt3support/itemviews/q3listview.cpp

equal deleted inserted replaced

--1:000000000000
+:1918ee327afb
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <qplatformdefs.h>
+#include "q3listview.h"
+#ifndef QT_NO_LISTVIEW
+#include "q3tl.h"
+#include "qapplication.h"
+#include "qbitmap.h"
+#include "q3cleanuphandler.h"
+#include "qcursor.h"
+#include "qdatetime.h"
+#include "q3dragobject.h"
+#include "qevent.h"
+#include "qhash.h"
+#include "q3header.h"
+#include "qicon.h"
+#include "qlineedit.h"
+#include "qpainter.h"
+#include "qpixmapcache.h"
+#include "qstack.h"
+#include "qstyle.h"
+#include "qstyleoption.h"
+#include "qtimer.h"
+#include "qtooltip.h"
+#include "qdebug.h"
+#ifndef QT_NO_ACCESSIBILITY
+#include "qaccessible.h"
+#endif
+QT_BEGIN_NAMESPACE
+const int Unsorted = 16383;
+static Q3CleanupHandler<QBitmap> qlv_cleanup_bitmap;
+struct Q3ListViewPrivate
+{
+// classes that are here to avoid polluting the global name space
+// the magical hidden mother of all items
+class Root: public Q3ListViewItem {
+public:
+Root(Q3ListView * parent);
+void setHeight(int);
+void invalidateHeight();
+void setup();
+Q3ListView * theListView() const;
+Q3ListView * lv;
+};
+// to remember what's on screen
+class DrawableItem {
+public:
+DrawableItem() {}
+DrawableItem(int level, int ypos, Q3ListViewItem * item)
+: l(level), y(ypos), i(item) {};
+int l;
+int y;
+Q3ListViewItem * i;
+};
+// for sorting
+class SortableItem {
+public:
+/*
+We could be smarter and keep a pointer to the Q3ListView
+item instead of numCols, col and asc. This would then allow
+us to use the physical ordering of columns rather than the
+logical. Microsoft uses the logical ordering, so there is
+some virtue in doing so, although it prevents the user from
+choosing the secondary key.
+*/
+Q3ListViewItem * item;
+int numCols;
+int col;
+bool asc;
+int cmp(const SortableItem& i) const {
+int diff = item->compare(i.item, col, asc);
+if (diff == 0 && numCols != 1) {
+for (int j = 0; j < numCols; j++) {
+if (j != col) {
+diff = item->compare(i.item, j, asc);
+if (diff != 0)
+break;
+}
+}
+}
+return diff;
+}
+bool operator<(const SortableItem& i) const { return cmp(i) < 0; }
+bool operator<=(const SortableItem& i) const { return cmp(i) <= 0; }
+bool operator>(const SortableItem& i) const { return cmp(i) > 0; }
+};
+class ItemColumnInfo {
+public:
+ItemColumnInfo(): pm(0), next(0), truncated(false), dirty(false), allow_rename(false), width(0) {}
+~ItemColumnInfo() { delete pm; delete next; }
+QString text, tmpText;
+QPixmap * pm;
+ItemColumnInfo * next;
+uint truncated : 1;
+uint dirty : 1;
+uint allow_rename : 1;
+int width;
+};
+class ViewColumnInfo {
+public:
+ViewColumnInfo(): align(Qt::AlignAuto), sortable(true), next(0) {}
+~ViewColumnInfo() { delete next; }
+int align;
+bool sortable;
+ViewColumnInfo * next;
+};
+// private variables used in Q3ListView
+ViewColumnInfo * vci;
+Q3Header * h;
+Root * r;
+uint rootIsExpandable : 1;
+int margin;
+Q3ListViewItem * focusItem, *highlighted, *oldFocusItem;
+QTimer * timer;
+QTimer * dirtyItemTimer;
+QTimer * visibleTimer;
+int levelWidth;
+// the list of drawables, and the range drawables covers entirely
+// (it may also include a few items above topPixel)
+QList<DrawableItem> drawables;
+int topPixel;
+int bottomPixel;
+QList<const Q3ListViewItem *> dirtyItems;
+Q3ListView::SelectionMode selectionMode;
+// Per-column structure for information not in the Q3Header
+struct Column {
+Q3ListView::WidthMode wmode;
+};
+QVector<Column> column;
+// suggested height for the items
+int fontMetricsHeight;
+int minLeftBearing, minRightBearing;
+int ellipsisWidth;
+// currently typed prefix for the keyboard interface, and the time
+// of the last key-press
+QString currentPrefix;
+QTime currentPrefixTime;
+// holds a list of iterators
+QList<Q3ListViewItemIterator *> iterators;
+Q3ListViewItem *pressedItem, *selectAnchor;
+QTimer *scrollTimer;
+QTimer *renameTimer;
+QTimer *autoopenTimer;
+// sort column and order   #### may need to move to Q3Header [subclass]
+int sortcolumn;
+bool ascending                :1;
+bool sortIndicator                :1;
+// whether to select or deselect during this mouse press.
+bool allColumnsShowFocus        :1;
+bool select                        :1;
+// true if the widget should take notice of mouseReleaseEvent
+bool buttonDown                :1;
+// true if the widget should ignore a double-click
+bool ignoreDoubleClick        :1;
+bool clearing                :1;
+bool pressedSelected        :1;
+bool pressedEmptyArea         :1;
+bool toolTips                :1;
+bool fullRepaintOnComlumnChange:1;
+bool updateHeader                :1;
+bool startEdit : 1;
+bool ignoreEditAfterFocus : 1;
+bool inMenuMode :1;
+Q3ListView::RenameAction defRenameAction;
+Q3ListViewItem *startDragItem;
+QPoint dragStartPos;
+int pressedColumn;
+Q3ListView::ResizeMode resizeMode;
+};
+Q_DECLARE_TYPEINFO(Q3ListViewPrivate::DrawableItem, Q_PRIMITIVE_TYPE);
+// these should probably be in Q3ListViewPrivate, for future thread safety
+static bool activatedByClick;
+static QPoint activatedP;
+#ifndef QT_NO_ACCESSIBILITY
+static int indexOfItem(Q3ListViewItem *item)
+{
+if (!QAccessible::isActive())
+return 0;
+static Q3ListViewItem *lastItem = 0;
+static int lastIndex = 0;
+if (!item || !item->listView())
+return 0;
+if (item == lastItem)
+return lastIndex;
+lastItem = item;
+int index = 1;
+Q3ListViewItemIterator it(item->listView());
+while (it.current()) {
+if (it.current() == item) {
+lastIndex = index;
+return index;
+}
+++it;
+++index;
+}
+lastIndex = 0;
+return 0;
+}
+#endif
+/*!
+Creates a string with ... like "Trollte..." or "...olltech", depending on the alignment.
+*/
+static QString qEllipsisText(const QString &org, const QFontMetrics &fm, int width, int align)
+{
+int ellWidth = fm.width(QLatin1String("..."));
+QString text = QString::fromLatin1("");
+int i = 0;
+int len = org.length();
+int offset = (align & Qt::AlignRight) ? (len-1) - i : i;
+while (i < len && fm.width(text + org[offset]) + ellWidth < width) {
+if (align & Qt::AlignRight)
+text.prepend(org[offset]);
+else
+text += org[offset];
+offset = (align & Qt::AlignRight) ? (len-1) - ++i : ++i;
+}
+if (text.isEmpty())
+text = (align & Qt::AlignRight) ? org.right(1) : text = org.left(1);
+if (align & Qt::AlignRight)
+text.prepend(QLatin1String("..."));
+else
+text += QLatin1String("...");
+return text;
+}
+/*!
+\class Q3ListViewItem
+\brief The Q3ListViewItem class implements a list view item.
+\compat
+A list view item is a multi-column object capable of displaying
+itself in a Q3ListView.
+The easiest way to use Q3ListViewItem is to construct one with a
+few constant strings, and either a Q3ListView or another
+Q3ListViewItem as parent.
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 0
+We've discarded the pointers to the items since we can still access
+them via their parent \e listView. By default, Q3ListView sorts its
+items; this can be switched off with Q3ListView::setSorting(-1).
+The parent must be another Q3ListViewItem or a Q3ListView. If the
+parent is a Q3ListView, the item becomes a top-level item within
+that Q3ListView. If the parent is another Q3ListViewItem, the item
+becomes a child of that list view item.
+If you keep the pointer, you can set or change the texts using
+setText(), add pixmaps using setPixmap(), change its mode using
+setSelectable(), setSelected(), setOpen() and setExpandable().
+You'll also be able to change its height using setHeight(), and
+traverse its sub-items. You don't have to keep the pointer since
+you can get a pointer to any Q3ListViewItem in a Q3ListView using
+Q3ListView::selectedItem(), Q3ListView::currentItem(),
+Q3ListView::firstChild(), Q3ListView::lastItem() and
+Q3ListView::findItem().
+If you call \c delete on a list view item, it will be deleted as
+expected, and as usual for \l{QObject}s, if it has any child items
+(to any depth), all these will be deleted too.
+\l{Q3CheckListItem}s are list view items that have a checkbox or
+radio button and can be used in place of plain Q3ListViewItems.
+You can traverse the tree as if it were a doubly-linked list using
+itemAbove() and itemBelow(); they return pointers to the items
+directly above and below this item on the screen (even if none of
+them are actually visible at the moment).
+Here's how to traverse all of an item's children (but not its
+children's children, etc.):
+Example:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 1
+If you want to iterate over every item, to any level of depth use
+an iterator. To iterate over the entire tree, initialize the
+iterator with the list view itself; to iterate over an item's
+children (and children's children to any depth), initialize the
+iterator with the item:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 2
+Note that the order of the children will change when the sorting
+order changes and is undefined if the items are not visible. You
+can, however, call enforceSortOrder() at any time; Q3ListView will
+always call it before it needs to show an item.
+Many programs will need to reimplement Q3ListViewItem. The most
+commonly reimplemented functions are:
+\table
+\header \i Function \i Description
+\row \i \l text()
+\i Returns the text in a column. Many subclasses will compute
+this on the fly.
+\row \i \l key()
+\i Used for sorting. The default key() simply calls
+text(), but judicious use of key() can give you fine
+control over sorting; for example, QFileDialog
+reimplements key() to sort by date.
+\row \i \l setup()
+\i Called before showing the item and whenever the list
+view's font changes, for example.
+\row \i \l activate()
+\i Called whenever the user clicks on the item or presses
+Space when the item is the current item.
+\endtable
+Some subclasses call setExpandable(true) even when they have no
+children, and populate themselves when setup() or setOpen(true) is
+called. The \c dirview/dirview.cpp example program uses this
+technique to start up quickly: The files and subdirectories in a
+directory aren't inserted into the tree until they're actually
+needed.
+\img qlistviewitems.png List View Items
+\sa Q3CheckListItem Q3ListView
+*/
+/*!
+\fn int Q3CheckListItem::rtti() const
+Returns 1.
+Make your derived classes return their own values for rtti(), and
+you can distinguish between list view items. You should use values
+greater than 1000, to allow for extensions to this class.
+*/
+/*!
+Constructs a new top-level list view item in the Q3ListView \a
+parent.
+*/
+Q3ListViewItem::Q3ListViewItem(Q3ListView * parent)
+{
+init();
+parent->insertItem(this);
+}
+/*!
+Constructs a new list view item that is a child of \a parent and
+first in the parent's list of children.
+*/
+Q3ListViewItem::Q3ListViewItem(Q3ListViewItem * parent)
+{
+init();
+parent->insertItem(this);
+}
+/*!
+Constructs an empty list view item that is a child of \a parent
+and is after item \a after in the parent's list of children. Since
+\a parent is a Q3ListView the item will be a top-level item.
+*/
+Q3ListViewItem::Q3ListViewItem(Q3ListView * parent, Q3ListViewItem * after)
+{
+init();
+parent->insertItem(this);
+moveToJustAfter(after);
+}
+/*!
+Constructs an empty list view item that is a child of \a parent
+and is after item \a after in the parent's list of children.
+*/
+Q3ListViewItem::Q3ListViewItem(Q3ListViewItem * parent, Q3ListViewItem * after)
+{
+init();
+parent->insertItem(this);
+moveToJustAfter(after);
+}
+/*!
+Constructs a new top-level list view item in the Q3ListView \a
+parent, with up to eight constant strings, \a label1, \a label2, \a
+label3, \a label4, \a label5, \a label6, \a label7 and \a label8
+defining its columns' contents.
+\sa setText()
+*/
+Q3ListViewItem::Q3ListViewItem(Q3ListView * parent,
+const QString &label1,
+const QString &label2,
+const QString &label3,
+const QString &label4,
+const QString &label5,
+const QString &label6,
+const QString &label7,
+const QString &label8)
+{
+init();
+parent->insertItem(this);
+setText(0, label1);
+setText(1, label2);
+setText(2, label3);
+setText(3, label4);
+setText(4, label5);
+setText(5, label6);
+setText(6, label7);
+setText(7, label8);
+}
+/*!
+Constructs a new list view item as a child of the Q3ListViewItem \a
+parent with up to eight constant strings, \a label1, \a label2, \a
+label3, \a label4, \a label5, \a label6, \a label7 and \a label8
+as columns' contents.
+\sa setText()
+*/
+Q3ListViewItem::Q3ListViewItem(Q3ListViewItem * parent,
+const QString &label1,
+const QString &label2,
+const QString &label3,
+const QString &label4,
+const QString &label5,
+const QString &label6,
+const QString &label7,
+const QString &label8)
+{
+init();
+parent->insertItem(this);
+setText(0, label1);
+setText(1, label2);
+setText(2, label3);
+setText(3, label4);
+setText(4, label5);
+setText(5, label6);
+setText(6, label7);
+setText(7, label8);
+}
+/*!
+Constructs a new list view item in the Q3ListView \a parent that is
+included after item \a after and that has up to eight column
+texts, \a label1, \a label2, \a label3, \a label4, \a label5, \a
+label6, \a label7 and\a label8.
+Note that the order is changed according to Q3ListViewItem::key()
+unless the list view's sorting is disabled using
+Q3ListView::setSorting(-1).
+\sa setText()
+*/
+Q3ListViewItem::Q3ListViewItem(Q3ListView * parent, Q3ListViewItem * after,
+const QString &label1,
+const QString &label2,
+const QString &label3,
+const QString &label4,
+const QString &label5,
+const QString &label6,
+const QString &label7,
+const QString &label8)
+{
+init();
+parent->insertItem(this);
+moveToJustAfter(after);
+setText(0, label1);
+setText(1, label2);
+setText(2, label3);
+setText(3, label4);
+setText(4, label5);
+setText(5, label6);
+setText(6, label7);
+setText(7, label8);
+}
+/*!
+Constructs a new list view item as a child of the Q3ListViewItem \a
+parent. It is inserted after item \a after and may contain up to
+eight strings, \a label1, \a label2, \a label3, \a label4, \a
+label5, \a label6, \a label7 and \a label8 as column entries.
+Note that the order is changed according to Q3ListViewItem::key()
+unless the list view's sorting is disabled using
+Q3ListView::setSorting(-1).
+\sa setText()
+*/
+Q3ListViewItem::Q3ListViewItem(Q3ListViewItem * parent, Q3ListViewItem * after,
+const QString &label1,
+const QString &label2,
+const QString &label3,
+const QString &label4,
+const QString &label5,
+const QString &label6,
+const QString &label7,
+const QString &label8)
+{
+init();
+parent->insertItem(this);
+moveToJustAfter(after);
+setText(0, label1);
+setText(1, label2);
+setText(2, label3);
+setText(3, label4);
+setText(4, label5);
+setText(5, label6);
+setText(6, label7);
+setText(7, label8);
+}
+/*!
+Sorts all this item's child items using the current sorting
+configuration (sort column and direction).
+\sa enforceSortOrder()
+*/
+void Q3ListViewItem::sort()
+{
+if (!listView())
+return;
+lsc = Unsorted;
+enforceSortOrder();
+listView()->triggerUpdate();
+}
+/*!
+Returns 0.
+Make your derived classes return their own values for rtti(), so
+that you can distinguish between different kinds of list view
+items. You should use values greater than 1000 to allow for
+extensions to this class.
+*/
+int Q3ListViewItem::rtti() const
+{
+return RTTI;
+}
+/*
+Performs the initializations that's common to the constructors.
+*/
+void Q3ListViewItem::init()
+{
+ownHeight = 0;
+maybeTotalHeight = -1;
+open = false;
+nChildren = 0;
+parentItem = 0;
+siblingItem = childItem = 0;
+columns = 0;
+selected = 0;
+selectable = true;
+lsc = Unsorted;
+lso = true; // unsorted in ascending order :)
+configured = false;
+expandable = false;
+selectable = true;
+is_root = false;
+allow_drag = false;
+allow_drop = false;
+visible = true;
+renameBox = 0;
+enabled = true;
+mlenabled = false;
+}
+/*!
+If \a b is true, the item is made visible; otherwise it is hidden.
+If the item is not visible, itemAbove() and itemBelow() will never
+return this item, although you still can reach it by using e.g.
+Q3ListViewItemIterator.
+*/
+void Q3ListViewItem::setVisible(bool b)
+{
+if (b == (bool)visible)
+return;
+Q3ListView *lv = listView();
+if (!lv)
+return;
+if (b && parent() && !parent()->isVisible())
+return;
+visible = b;
+configured = false;
+setHeight(0);
+invalidateHeight();
+if (parent())
+parent()->invalidateHeight();
+else
+lv->d->r->invalidateHeight();
+for (Q3ListViewItem *i = childItem; i; i = i->siblingItem)
+i->setVisible(b);
+if (lv)
+lv->triggerUpdate();
+}
+/*!
+Returns true if the item is visible; otherwise returns false.
+\sa setVisible()
+*/
+bool Q3ListViewItem::isVisible() const
+{
+return (bool)visible;
+}
+/*!
+If \a b is true, this item can be in-place renamed in the column
+\a col by the user; otherwise it cannot be renamed in-place.
+*/
+void Q3ListViewItem::setRenameEnabled(int col, bool b)
+{
+Q3ListViewPrivate::ItemColumnInfo * l = (Q3ListViewPrivate::ItemColumnInfo*)columns;
+if (!l) {
+l = new Q3ListViewPrivate::ItemColumnInfo;
+columns = (void*)l;
+}
+for(int c = 0; c < col; c++) {
+if (!l->next)
+l->next = new Q3ListViewPrivate::ItemColumnInfo;
+l = l->next;
+}
+if (!l)
+return;
+l->allow_rename = b;
+}
+/*!
+Returns true if this item can be in-place renamed in column \a
+col; otherwise returns false.
+*/
+bool Q3ListViewItem::renameEnabled(int col) const
+{
+Q3ListViewPrivate::ItemColumnInfo * l = (Q3ListViewPrivate::ItemColumnInfo*)columns;
+if (!l)
+return false;
+while(col && l) {
+l = l->next;
+col--;
+}
+if (!l)
+return false;
+return (bool)l->allow_rename;
+}
+/*!
+If \a b is true the item is enabled; otherwise it is disabled.
+Disabled items are drawn differently (e.g. grayed-out) and are not
+accessible by the user.
+*/
+void Q3ListViewItem::setEnabled(bool b)
+{
+if ((bool)enabled == b)
+return;
+enabled = b;
+if (!enabled)
+selected = false;
+Q3ListView *lv = listView();
+if (lv) {
+lv->triggerUpdate();
+#ifndef QT_NO_ACCESSIBILITY
+QAccessible::updateAccessibility(lv->viewport(), indexOfItem(this), QAccessible::StateChanged);
+#endif
+}
+}
+/*!
+Returns true if this item is enabled; otherwise returns false.
+\sa setEnabled()
+*/
+bool Q3ListViewItem::isEnabled() const
+{
+return (bool)enabled;
+}
+/*!
+If in-place renaming of this item is enabled (see
+renameEnabled()), this function starts renaming the item in column
+\a col, by creating and initializing an edit box.
+*/
+void Q3ListViewItem::startRename(int col)
+{
+if (!renameEnabled(col))
+return;
+if (renameBox)
+cancelRename(col);
+Q3ListView *lv = listView();
+if (!lv)
+return;
+if (lv->d->renameTimer)
+lv->d->renameTimer->stop();
+lv->ensureItemVisible(this);
+if (lv->d->timer->isActive()) {
+// make sure that pending calculations get finished
+lv->d->timer->stop();
+lv->updateContents();
+}
+if (lv->currentItem() && lv->currentItem()->renameBox) {
+if (lv->d->defRenameAction == Q3ListView::Reject)
+lv->currentItem()->cancelRename(lv->currentItem()->renameCol);
+else
+lv->currentItem()->okRename(lv->currentItem()->renameCol);
+}
+if (this != lv->currentItem())
+lv->setCurrentItem(this);
+QRect r = lv->itemRect(this);
+r = QRect(lv->viewportToContents(r.topLeft()), r.size());
+r.setLeft(lv->header()->sectionPos(col));
+r.setWidth(qMin(lv->header()->sectionSize(col) - 1,
+lv->contentsX() + lv->visibleWidth() - r.left()));
+if (col == 0)
+r.setLeft(r.left() + lv->itemMargin() + (depth() + (lv->rootIsDecorated() ? 1 : 0)) * lv->treeStepSize() - 1);
+if (pixmap(col))
+r.setLeft(r.left() + pixmap(col)->width());
+if (r.x() - lv->contentsX() < 0) {
+lv->scrollBy(r.x() - lv->contentsX(), 0);
+r.setX(lv->contentsX());
+} else if ((lv->contentsX() + lv->visibleWidth()) < (r.x() + r.width())) {
+lv->scrollBy((r.x() + r.width()) - (lv->contentsX() + lv->visibleWidth()), 0);
+}
+if (r.width() > lv->visibleWidth())
+r.setWidth(lv->visibleWidth());
+renameBox = new QLineEdit(lv->viewport(), "qt_renamebox");
+renameBox->setFrame(false);
+renameBox->setText(text(col));
+renameBox->selectAll();
+renameBox->installEventFilter(lv);
+lv->addChild(renameBox, r.x(), r.y());
+renameBox->resize(r.size());
+lv->viewport()->setFocusProxy(renameBox);
+renameBox->setFocus();
+renameBox->show();
+renameCol = col;
+}
+/*!
+This function removes the rename box.
+*/
+void Q3ListViewItem::removeRenameBox()
+{
+// Sanity, it should be checked by the functions calling this first anyway
+Q3ListView *lv = listView();
+if (!lv || !renameBox)
+return;
+const bool resetFocus = lv->viewport()->focusProxy() == renameBox;
+delete renameBox;
+renameBox = 0;
+if (resetFocus) {
+lv->viewport()->setFocusProxy(lv);
+lv->setFocus();
+}
+}
+/*!
+This function is called if the user presses Enter during in-place
+renaming of the item in column \a col.
+\sa cancelRename()
+*/
+void Q3ListViewItem::okRename(int col)
+{
+Q3ListView *lv = listView();
+if (!lv || !renameBox)
+return;
+setText(col, renameBox->text());
+removeRenameBox();
+// we set the parent lsc to Unsorted if that column is the sorted one
+if (parent() && (int)parent()->lsc == col)
+parent()->lsc = Unsorted;
+emit lv->itemRenamed(this, col);
+emit lv->itemRenamed(this, col, text(col));
+}
+/*!
+This function is called if the user cancels in-place renaming of
+this item in column \a col (e.g. by pressing Esc).
+\sa okRename()
+*/
+void Q3ListViewItem::cancelRename(int)
+{
+Q3ListView *lv = listView();
+if (!lv || !renameBox)
+return;
+removeRenameBox();
+}
+/*!
+Destroys the item, deleting all its children and freeing up all
+allocated resources.
+*/
+Q3ListViewItem::~Q3ListViewItem()
+{
+if (renameBox) {
+delete renameBox;
+renameBox = 0;
+}
+Q3ListView *lv = listView();
+if (lv) {
+if (lv->d->oldFocusItem == this)
+lv->d->oldFocusItem = 0;
+if (lv->d->focusItem == this)
+lv->d->focusItem = 0;
+if (lv->d->highlighted == this)
+lv->d->highlighted = 0;
+if (lv->d->pressedItem == this)
+lv->d->pressedItem = 0;
+if (lv->d->selectAnchor == this)
+lv->d->selectAnchor = 0;
+for (int j = 0; j < lv->d->iterators.size(); ++j) {
+Q3ListViewItemIterator *i = lv->d->iterators.at(j);
+if (i->current() == this)
+i->currentRemoved();
+}
+}
+if (parentItem)
+parentItem->takeItem(this);
+Q3ListViewItem * i = childItem;
+childItem = 0;
+while (i) {
+i->parentItem = 0;
+Q3ListViewItem * n = i->siblingItem;
+delete i;
+i = n;
+}
+delete (Q3ListViewPrivate::ItemColumnInfo *)columns;
+}
+/*!
+If \a b is true each of the item's columns may contain multiple
+lines of text; otherwise each of them may only contain a single
+line.
+*/
+void Q3ListViewItem::setMultiLinesEnabled(bool b)
+{
+mlenabled = b;
+}
+/*!
+Returns true if the item can display multiple lines of text in its
+columns; otherwise returns false.
+*/
+bool Q3ListViewItem::multiLinesEnabled() const
+{
+return mlenabled;
+}
+/*!
+If \a allow is true, the list view starts a drag (see
+Q3ListView::dragObject()) when the user presses and moves the mouse
+on this item.
+*/
+void Q3ListViewItem::setDragEnabled(bool allow)
+{
+allow_drag = (uint)allow;
+}
+/*!
+If \a allow is true, the list view accepts drops onto the item;
+otherwise drops are not allowed.
+*/
+void Q3ListViewItem::setDropEnabled(bool allow)
+{
+allow_drop = (uint)allow;
+}
+/*!
+Returns true if this item can be dragged; otherwise returns false.
+\sa setDragEnabled()
+*/
+bool Q3ListViewItem::dragEnabled() const
+{
+return (bool)allow_drag;
+}
+/*!
+Returns true if this item accepts drops; otherwise returns false.
+\sa setDropEnabled(), acceptDrop()
+*/
+bool Q3ListViewItem::dropEnabled() const
+{
+return (bool)allow_drop;
+}
+/*!
+Returns true if the item can accept drops of type QMimeSource \a
+mime; otherwise returns false.
+The default implementation does nothing and returns false. A
+subclass must reimplement this to accept drops.
+*/
+bool Q3ListViewItem::acceptDrop(const QMimeSource *) const
+{
+return false;
+}
+#ifndef QT_NO_DRAGANDDROP
+/*!
+This function is called when something was dropped on the item. \a e
+contains all the information about the drop.
+The default implementation does nothing, subclasses may need to
+reimplement this function.
+*/
+void Q3ListViewItem::dropped(QDropEvent *e)
+{
+Q_UNUSED(e);
+}
+#endif
+/*!
+This function is called when a drag enters the item's bounding
+rectangle.
+The default implementation does nothing, subclasses may need to
+reimplement this function.
+*/
+void Q3ListViewItem::dragEntered()
+{
+}
+/*!
+This function is called when a drag leaves the item's bounding
+rectangle.
+The default implementation does nothing, subclasses may need to
+reimplement this function.
+*/
+void Q3ListViewItem::dragLeft()
+{
+}
+/*!
+Inserts \a newChild into this list view item's list of children.
+You should not need to call this function; it is called
+automatically by the constructor of \a newChild.
+\warning If you are using \c Single selection mode, then you
+should only insert unselected items.
+*/
+void Q3ListViewItem::insertItem(Q3ListViewItem * newChild)
+{
+Q3ListView *lv = listView();
+if (lv && lv->currentItem() && lv->currentItem()->renameBox) {
+if (lv->d->defRenameAction == Q3ListView::Reject)
+lv->currentItem()->cancelRename(lv->currentItem()->renameCol);
+else
+lv->currentItem()->okRename(lv->currentItem()->renameCol);
+}
+if (!newChild || newChild->parentItem == this)
+return;
+if (newChild->parentItem)
+newChild->parentItem->takeItem(newChild);
+if (open)
+invalidateHeight();
+newChild->siblingItem = childItem;
+childItem = newChild;
+nChildren++;
+newChild->parentItem = this;
+lsc = Unsorted;
+newChild->ownHeight = 0;
+newChild->configured = false;
+if (lv && !lv->d->focusItem) {
+lv->d->focusItem = lv->firstChild();
+lv->d->selectAnchor = lv->d->focusItem;
+lv->repaintItem(lv->d->focusItem);
+}
+}
+/*!
+\fn void Q3ListViewItem::removeItem(Q3ListViewItem *item)
+Removes the given \a item. Use takeItem() instead.
+*/
+/*!
+Removes \a item from this object's list of children and causes an
+update of the screen display. The item is not deleted. You should
+not normally need to call this function because
+Q3ListViewItem::~Q3ListViewItem() calls it.
+The normal way to delete an item is to use \c delete.
+If you need to move an item from one place in the hierarchy to
+another you can use takeItem() to remove the item from the list
+view and then insertItem() to put the item back in its new
+position.
+If a taken item is part of a selection in \c Single selection
+mode, it is unselected and selectionChanged() is emitted. If a
+taken item is part of a selection in \c Multi or \c Extended
+selection mode, it remains selected.
+\warning This function leaves \a item and its children in a state
+where most member functions are unsafe. Only a few functions work
+correctly on an item in this state, most notably insertItem(). The
+functions that work on taken items are explicitly documented as
+such.
+\sa Q3ListViewItem::insertItem()
+*/
+void Q3ListViewItem::takeItem(Q3ListViewItem * item)
+{
+if (!item)
+return;
+Q3ListView *lv = listView();
+if (lv && lv->currentItem() && lv->currentItem()->renameBox) {
+if (lv->d->defRenameAction == Q3ListView::Reject)
+lv->currentItem()->cancelRename(lv->currentItem()->renameCol);
+else
+lv->currentItem()->okRename(lv->currentItem()->renameCol);
+}
+bool emit_changed = false;
+if (lv && !lv->d->clearing) {
+if (lv->d->oldFocusItem == this)
+lv->d->oldFocusItem = 0;
+for (int j = 0; j < lv->d->iterators.size(); ++j) {
+Q3ListViewItemIterator *i = lv->d->iterators.at(j);
+if (i->current() == item)
+i->currentRemoved();
+}
+invalidateHeight();
+if (lv->d && !lv->d->drawables.isEmpty())
+lv->d->drawables.clear();
+if (!lv->d->dirtyItems.isEmpty()) {
+if (item->childItem) {
+lv->d->dirtyItems.clear();
+lv->d->dirtyItemTimer->stop();
+lv->triggerUpdate();
+} else {
+lv->d->dirtyItems.removeAll(item);
+}
+}
+if (lv->d->focusItem) {
+const Q3ListViewItem * c = lv->d->focusItem;
+while(c && c != item)
+c = c->parentItem;
+if (c == item) {
+if (lv->selectedItem()) {
+// for Single, setSelected(false) when selectedItem() is taken
+lv->selectedItem()->setSelected(false);
+// we don't emit selectionChanged(0)
+emit lv->selectionChanged();
+}
+if (item->nextSibling())
+lv->d->focusItem = item->nextSibling();
+else if (item->itemAbove())
+lv->d->focusItem = item->itemAbove();
+else
+lv->d->focusItem = 0;
+emit_changed = true;
+}
+}
+// reset anchors etc. if they are set to this or any child
+// items
+const Q3ListViewItem *ptr = lv->d->selectAnchor;
+while (ptr && ptr != item)
+ptr = ptr->parentItem;
+	if (ptr == item)
+	    lv->d->selectAnchor = lv->d->focusItem;
+ptr = lv->d->startDragItem;
+while (ptr && ptr != item)
+ptr = ptr->parentItem;
+	if (ptr == item)
+	    lv->d->startDragItem = 0;
+ptr = lv->d->pressedItem;
+while (ptr && ptr != item)
+ptr = ptr->parentItem;
+	if (ptr == item)
+	    lv->d->pressedItem = 0;
+ptr = lv->d->highlighted;
+while (ptr && ptr != item)
+ptr = ptr->parentItem;
+	if (ptr == item)
+	    lv->d->highlighted = 0;
+}
+nChildren--;
+Q3ListViewItem ** nextChild = &childItem;
+while(nextChild && *nextChild && item != *nextChild)
+nextChild = &((*nextChild)->siblingItem);
+if (nextChild && item == *nextChild)
+*nextChild = (*nextChild)->siblingItem;
+item->parentItem = 0;
+item->siblingItem = 0;
+item->ownHeight = 0;
+item->maybeTotalHeight = -1;
+item->configured = false;
+if (emit_changed) {
+emit lv->currentChanged(lv->d->focusItem);
+#ifndef QT_NO_ACCESSIBILITY
+QAccessible::updateAccessibility(lv->viewport(), 0, QAccessible::Focus);
+#endif
+}
+}
+/*!
+\fn QString Q3ListViewItem::key(int column, bool ascending) const
+Returns a key that can be used for sorting by column \a column.
+The default implementation returns text(). Derived classes may
+also incorporate the order indicated by \a ascending into this
+key, although this is not recommended.
+If you want to sort on non-alphabetical data, e.g. dates, numbers,
+etc., it is more efficient to reimplement compare().
+\sa compare(), sortChildItems()
+*/
+QString Q3ListViewItem::key(int column, bool) const
+{
+return text(column);
+}
+/*!
+Compares this list view item to \a i using the column \a col in \a
+ascending order. Returns \< 0 if this item is less than \a i, 0 if
+they are equal and \> 0 if this item is greater than \a i.
+This function is used for sorting.
+The default implementation compares the item keys (key()) using
+QString::localeAwareCompare(). A reimplementation can use
+different values and a different comparison function. Here is a
+reimplementation that uses plain Unicode comparison:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 3
+We don't recommend using \a ascending so your code can safely
+ignore it.
+\sa key() QString::localeAwareCompare() QString::compare()
+*/
+int Q3ListViewItem::compare(Q3ListViewItem *i, int col, bool ascending) const
+{
+return key(col, ascending).localeAwareCompare(i->key(col, ascending));
+}
+/*!
+Sorts this item's children using column \a column. This is done in
+ascending order if \a ascending is true and in descending order if
+\a ascending is false.
+Asks some of the children to sort their children. (Q3ListView and
+Q3ListViewItem ensure that all on-screen objects are properly
+sorted but may avoid or defer sorting other objects in order to be
+more responsive.)
+\sa key() compare()
+*/
+void Q3ListViewItem::sortChildItems(int column, bool ascending)
+{
+// we try HARD not to sort.  if we're already sorted, don't.
+if (column == (int)lsc && ascending == (bool)lso)
+return;
+if (column < 0)
+return;
+lsc = column;
+lso = ascending;
+const int nColumns = (listView() ? listView()->columns() : 0);
+// and don't sort if we already have the right sorting order
+if (column > nColumns || childItem == 0 || childItem->siblingItem == 0)
+return;
+// make an array for qHeapSort()
+Q3ListViewPrivate::SortableItem * siblings
+= new Q3ListViewPrivate::SortableItem[nChildren];
+Q3ListViewItem * s = childItem;
+int i = 0;
+while (s && i < nChildren) {
+siblings[i].numCols = nColumns;
+siblings[i].col = column;
+siblings[i].asc = ascending;
+siblings[i].item = s;
+s = s->siblingItem;
+i++;
+}
+// and sort it.
+qHeapSort(siblings, siblings + nChildren);
+// build the linked list of siblings, in the appropriate
+// direction, and finally set this->childItem to the new top
+// child.
+if (ascending) {
+for(i = 0; i < nChildren - 1; i++)
+siblings[i].item->siblingItem = siblings[i+1].item;
+siblings[nChildren-1].item->siblingItem = 0;
+childItem = siblings[0].item;
+} else {
+for(i = nChildren - 1; i > 0; i--)
+siblings[i].item->siblingItem = siblings[i-1].item;
+siblings[0].item->siblingItem = 0;
+childItem = siblings[nChildren-1].item;
+}
+for (i = 0; i < nChildren; i++) {
+if (siblings[i].item->isOpen())
+siblings[i].item->sort();
+}
+delete[] siblings;
+}
+/*!
+Sets this item's height to \a height pixels. This implicitly
+changes totalHeight(), too.
+Note that a font change causes this height to be overwritten
+unless you reimplement setup().
+For best results in Windows style we suggest using an even number
+of pixels.
+\sa height() totalHeight() isOpen()
+*/
+void Q3ListViewItem::setHeight(int height)
+{
+if (ownHeight != height) {
+if (visible)
+ownHeight = height;
+else
+ownHeight = 0;
+invalidateHeight();
+}
+}
+/*!
+Invalidates the cached total height of this item, including all
+open children.
+\sa setHeight() height() totalHeight()
+*/
+void Q3ListViewItem::invalidateHeight()
+{
+if (maybeTotalHeight < 0)
+return;
+maybeTotalHeight = -1;
+if (parentItem && parentItem->isOpen())
+parentItem->invalidateHeight();
+}
+/*!
+Opens or closes an item, i.e. shows or hides an item's children.
+If \a o is true all child items are shown initially. The user can
+hide them by clicking the \bold{-} icon to the left of the item.
+If \a o is false, the children of this item are initially hidden.
+The user can show them by clicking the \bold{+} icon to the left
+of the item.
+\sa height() totalHeight() isOpen()
+*/
+void Q3ListViewItem::setOpen(bool o)
+{
+if (o == (bool)open || !enabled)
+return;
+open = o;
+// If no children to show simply emit signals and return
+if (!nChildren) {
+Q3ListView *lv = listView();
+if (lv && this != lv->d->r) {
+if (o)
+emit lv->expanded(this);
+else
+emit lv->collapsed(this);
+#ifndef QT_NO_ACCESSIBILITY
+QAccessible::updateAccessibility(lv->viewport(), indexOfItem(this), QAccessible::StateChanged);
+#endif
+}
+return;
+}
+invalidateHeight();
+if (!configured) {
+Q3ListViewItem * l = this;
+QStack<Q3ListViewItem *> s;
+while(l) {
+if (l->open && l->childItem) {
+s.push(l->childItem);
+} else if (l->childItem) {
+// first invisible child is unconfigured
+Q3ListViewItem * c = l->childItem;
+while(c) {
+c->configured = false;
+c = c->siblingItem;
+}
+}
+l->configured = true;
+l->setup();
+l = (l == this) ? 0 : l->siblingItem;
+if (!l && !s.isEmpty())
+l = s.pop();
+}
+}
+Q3ListView *lv = listView();
+if (open && lv)
+enforceSortOrder();
+if (isVisible() && lv && lv->d && !lv->d->drawables.isEmpty())
+lv->buildDrawableList();
+if (lv && this != lv->d->r) {
+if (o)
+emit lv->expanded(this);
+else
+emit lv->collapsed(this);
+#ifndef QT_NO_ACCESSIBILITY
+QAccessible::updateAccessibility(lv->viewport(), indexOfItem(this), QAccessible::StateChanged);
+#endif
+}
+}
+/*!
+This virtual function is called before the first time Q3ListView
+needs to know the height or any other graphical attribute of this
+object, and whenever the font, GUI style, or colors of the list
+view change.
+The default calls widthChanged() and sets the item's height to the
+height of a single line of text in the list view's font. (If you
+use icons, multi-line text, etc., you will probably need to call
+setHeight() yourself or reimplement it.)
+*/
+void Q3ListViewItem::setup()
+{
+widthChanged();
+Q3ListView *lv = listView();
+int ph = 0;
+int h = 0;
+if (lv) {
+for (int i = 0; i < lv->d->column.size(); ++i) {
+if (pixmap(i))
+ph = qMax(ph, pixmap(i)->height());
+}
+if (mlenabled) {
+h = ph;
+for (int c = 0; c < lv->columns(); ++c) {
+int lines = text(c).count(QLatin1Char('\n')) + 1;
+int tmph = lv->d->fontMetricsHeight
++ lv->fontMetrics().lineSpacing() * (lines - 1);
+h = qMax(h, tmph);
+}
+h += 2*lv->itemMargin();
+} else {
+h = qMax(lv->d->fontMetricsHeight, ph) + 2*lv->itemMargin();
+}
+}
+h = qMax(h, QApplication::globalStrut().height());
+if (h % 2 > 0)
+h++;
+setHeight(h);
+}
+/*!
+This virtual function is called whenever the user presses the mouse
+on this item or presses Space on it.
+\sa activatedPos()
+*/
+void Q3ListViewItem::activate()
+{
+}
+/*!
+When called from a reimplementation of activate(), this function
+gives information on how the item was activated. Otherwise the
+behavior is undefined.
+If activate() was caused by a mouse press, the function sets \a
+pos to where the user clicked and returns true; otherwise it
+returns false and does not change \a pos.
+\a pos is relative to the top-left corner of this item.
+\sa activate()
+*/
+bool Q3ListViewItem::activatedPos(QPoint &pos)
+{
+if (activatedByClick)
+pos = activatedP;
+return activatedByClick;
+}
+/*!
+\fn bool Q3ListViewItem::isSelectable() const
+Returns true if the item is selectable (as it is by default);
+otherwise returns false
+\sa setSelectable()
+*/
+/*!
+Sets this items to be selectable if \a enable is true (the
+default) or not to be selectable if \a enable is false.
+The user is not able to select a non-selectable item using either
+the keyboard or the mouse. The application programmer still can
+though, e.g. using setSelected().
+\sa isSelectable()
+*/
+void Q3ListViewItem::setSelectable(bool enable)
+{
+selectable = enable;
+}
+/*!
+\fn bool Q3ListViewItem::isExpandable() const
+Returns true if this item is expandable even when it has no
+children; otherwise returns false.
+*/
+/*!
+Sets this item to be expandable even if it has no children if \a
+enable is true, and to be expandable only if it has children if \a
+enable is false (the default).
+The dirview example uses this in the canonical fashion. It checks
+whether the directory is empty in setup() and calls
+setExpandable(true) if not; in setOpen() it reads the contents of
+the directory and inserts items accordingly. This strategy means
+that dirview can display the entire file system without reading
+very much at startup.
+Note that root items are not expandable by the user unless
+Q3ListView::setRootIsDecorated() is set to true.
+\sa setSelectable()
+*/
+void Q3ListViewItem::setExpandable(bool enable)
+{
+expandable = enable;
+}
+/*!
+Makes sure that this object's children are sorted appropriately.
+This only works if every item from the root item down to this item
+is already sorted.
+\sa sortChildItems()
+*/
+void Q3ListViewItem::enforceSortOrder() const
+{
+Q3ListView *lv = listView();
+if (!lv || (lv && (lv->d->clearing || lv->d->sortcolumn == Unsorted)))
+return;
+if (parentItem &&
+(parentItem->lsc != lsc || parentItem->lso != lso))
+((Q3ListViewItem *)this)->sortChildItems((int)parentItem->lsc,
+(bool)parentItem->lso);
+else if (!parentItem &&
+((int)lsc != lv->d->sortcolumn || (bool)lso != lv->d->ascending))
+((Q3ListViewItem *)this)->sortChildItems(lv->d->sortcolumn, lv->d->ascending);
+}
+/*!
+\fn bool Q3ListViewItem::isSelected() const
+Returns true if this item is selected; otherwise returns false.
+\sa setSelected() Q3ListView::setSelected() Q3ListView::selectionChanged()
+*/
+/*!
+If \a s is true this item is selected; otherwise it is deselected.
+This function does not maintain any invariants or repaint anything
+-- Q3ListView::setSelected() does that.
+\sa height() totalHeight()
+*/
+void Q3ListViewItem::setSelected(bool s)
+{
+bool old = selected;
+Q3ListView *lv = listView();
+if (lv && lv->selectionMode() != Q3ListView::NoSelection) {
+if (s && isSelectable())
+selected = true;
+else
+selected = false;
+#ifndef QT_NO_ACCESSIBILITY
+if (old != (bool)selected) {
+int ind = indexOfItem(this);
+QAccessible::updateAccessibility(lv->viewport(), ind, QAccessible::StateChanged);
+QAccessible::updateAccessibility(lv->viewport(), ind, selected ? QAccessible::SelectionAdd : QAccessible::SelectionRemove);
+}
+#else
+Q_UNUSED(old);
+#endif
+}
+}
+/*!
+Returns the total height of this object, including any visible
+children. This height is recomputed lazily and cached for as long
+as possible.
+Functions which can affect the total height are, setHeight() which
+is used to set an item's height, setOpen() to show or hide an
+item's children, and invalidateHeight() to invalidate the cached
+height.
+\sa height()
+*/
+int Q3ListViewItem::totalHeight() const
+{
+if (!visible)
+return 0;
+if (maybeTotalHeight >= 0)
+return maybeTotalHeight;
+Q3ListViewItem * that = (Q3ListViewItem *)this;
+if (!that->configured) {
+that->configured = true;
+that->setup(); // ### virtual non-const function called in const
+}
+that->maybeTotalHeight = that->ownHeight;
+if (!that->isOpen() || !that->childCount())
+return that->ownHeight;
+Q3ListViewItem * child = that->childItem;
+while (child != 0) {
+that->maybeTotalHeight += child->totalHeight();
+child = child->siblingItem;
+}
+return that->maybeTotalHeight;
+}
+/*!
+Returns the text in column \a column, or an empty string if there is
+no text in that column.
+\sa key() paintCell()
+*/
+QString Q3ListViewItem::text(int column) const
+{
+Q3ListViewPrivate::ItemColumnInfo * l
+= (Q3ListViewPrivate::ItemColumnInfo*) columns;
+while(column && l) {
+l = l->next;
+column--;
+}
+return l ? l->text : QString();
+}
+/*!
+Sets the text in column \a column to \a text, if \a column is a
+valid column number and \a text is different from the existing
+text.
+If the text() function has been reimplemented, this function may
+be a no-op.
+\sa text() key()
+*/
+void Q3ListViewItem::setText(int column, const QString &text)
+{
+if (column < 0)
+return;
+Q3ListViewPrivate::ItemColumnInfo * l
+= (Q3ListViewPrivate::ItemColumnInfo*) columns;
+if (!l) {
+l = new Q3ListViewPrivate::ItemColumnInfo;
+columns = (void*)l;
+}
+for(int c = 0; c < column; c++) {
+if (!l->next)
+l->next = new Q3ListViewPrivate::ItemColumnInfo;
+l = l->next;
+}
+if (l->text == text)
+return;
+int oldLc = 0;
+int newLc = 0;
+if (mlenabled) {
+if (!l->text.isEmpty())
+oldLc = l->text.count(QLatin1Char('\n')) + 1;
+if (!text.isEmpty())
+newLc = text.count(QLatin1Char('\n')) + 1;
+}
+l->dirty = true;
+l->text = text;
+if (column == (int)lsc)
+lsc = Unsorted;
+if (mlenabled && oldLc != newLc)
+setup();
+else
+widthChanged(column);
+Q3ListView * lv = listView();
+if (lv) {
+lv->triggerUpdate();
+#ifndef QT_NO_ACCESSIBILITY
+if (lv->isVisible())
+QAccessible::updateAccessibility(lv->viewport(), indexOfItem(this), QAccessible::NameChanged);
+#endif
+}
+}
+/*!
+Sets the pixmap in column \a column to \a pm, if \a pm is non-null
+and different from the current pixmap, and if \a column is
+non-negative.
+\sa pixmap() setText()
+*/
+void Q3ListViewItem::setPixmap(int column, const QPixmap & pm)
+{
+if (column < 0)
+return;
+int oldW = 0;
+int oldH = 0;
+if (pixmap(column)) {
+oldW = pixmap(column)->width();
+oldH = pixmap(column)->height();
+}
+Q3ListViewPrivate::ItemColumnInfo * l
+= (Q3ListViewPrivate::ItemColumnInfo*) columns;
+if (!l) {
+l = new Q3ListViewPrivate::ItemColumnInfo;
+columns = (void*)l;
+}
+for(int c = 0; c < column; c++) {
+if (!l->next)
+l->next = new Q3ListViewPrivate::ItemColumnInfo;
+l = l->next;
+}
+if ((pm.isNull() && (!l->pm || l->pm->isNull())) ||
+(l->pm && pm.serialNumber() == l->pm->serialNumber()))
+return;
+if (pm.isNull()) {
+delete l->pm;
+l->pm = 0;
+} else {
+if (l->pm)
+*(l->pm) = pm;
+else
+l->pm = new QPixmap(pm);
+}
+int newW = 0;
+int newH = 0;
+if (pixmap(column)) {
+newW = pixmap(column)->width();
+newH = pixmap(column)->height();
+}
+if (oldW != newW || oldH != newH) {
+setup();
+widthChanged(column);
+invalidateHeight();
+}
+Q3ListView *lv = listView();
+if (lv) {
+lv->triggerUpdate();
+}
+}
+/*!
+Returns the pixmap for \a column, or 0 if there is no pixmap for
+\a column.
+\sa setText() setPixmap()
+*/
+const QPixmap * Q3ListViewItem::pixmap(int column) const
+{
+Q3ListViewPrivate::ItemColumnInfo * l
+= (Q3ListViewPrivate::ItemColumnInfo*) columns;
+while(column && l) {
+l = l->next;
+column--;
+}
+return (l && l->pm) ? l->pm : 0;
+}
+/*
+This function paints the contents of one column of an item
+and aligns it as described by \a align.
+\a p is a QPainter open on the relevant paint device. \a p is
+translated so (0, 0) is the top-left pixel in the cell and \a
+width-1, height()-1 is the bottom-right pixel \e in the cell. The
+other properties of \a p (pen, brush, etc) are undefined. \a pal is
+the color group to use. \a column is the logical column number
+within the item that is to be painted; 0 is the column which may
+contain a tree.
+This function may use Q3ListView::itemMargin() for readability
+spacing on the left and right sides of data such as text, and
+should honor isSelected() and Q3ListView::allColumnsShowFocus().
+If you reimplement this function, you should also reimplement
+width().
+The rectangle to be painted is in an undefined state when this
+function is called, so you \e must draw on all the pixels. The
+painter \a p has the right font on entry.
+\sa paintBranches(), Q3ListView::drawContentsOffset()
+*/
+static QStyleOptionQ3ListView getStyleOption(const Q3ListView *lv, const Q3ListViewItem *item,
+bool hierarchy = false)
+{
+QStyleOptionQ3ListView opt;
+opt.init(lv);
+opt.subControls = QStyle::SC_None;
+opt.activeSubControls = QStyle::SC_None;
+QWidget *vp = lv->viewport();
+opt.viewportPalette = vp->palette();
+opt.viewportBGRole = vp->backgroundRole();
+opt.itemMargin = lv->itemMargin();
+opt.sortColumn = 0;
+opt.treeStepSize = lv->treeStepSize();
+opt.rootIsDecorated = lv->rootIsDecorated();
+bool firstItem = true;
+int y = item ? item->itemPos() : 0;
+while (item) {
+QStyleOptionQ3ListViewItem lvi;
+lvi.height = item->height();
+lvi.totalHeight = item->totalHeight();
+lvi.itemY = y;
+lvi.childCount = item->childCount();
+lvi.features = QStyleOptionQ3ListViewItem::None;
+lvi.state = QStyle::State_None;
+if (item->isEnabled())
+lvi.state |= QStyle::State_Enabled;
+if (item->isOpen())
+lvi.state |= QStyle::State_Open;
+if (item->isExpandable())
+lvi.features |= QStyleOptionQ3ListViewItem::Expandable;
+if (item->multiLinesEnabled())
+lvi.features |= QStyleOptionQ3ListViewItem::MultiLine;
+if (item->isVisible())
+lvi.features |= QStyleOptionQ3ListViewItem::Visible;
+if (item->parent() && item->parent()->rtti() == 1
+&& static_cast<Q3CheckListItem *>(item->parent())->type() == Q3CheckListItem::Controller)
+lvi.features |= QStyleOptionQ3ListViewItem::ParentControl;
+opt.items.append(lvi);
+// we only care about the children when we are painting the branches
+// this is only enabled by Q3ListViewItem::paintBranches
+if (hierarchy) {
+if (!firstItem) {
+item = item->nextSibling();
+} else {
+firstItem = false;
+item = item->firstChild();
+}
+y += lvi.height;
+} else {
+break;
+}
+}
+return opt;
+}
+/*!
+\fn void Q3ListViewItem::paintCell(QPainter *painter, const QColorGroup & cg, int column, int width, int align)
+This virtual function paints the contents of one column of an item
+and aligns it as described by \a align.
+The \a painter is a Q3Painter open on the relevant paint
+device. It is translated so (0, 0) is the top-left pixel in the
+cell and \a width - 1, height() - 1 is the bottom-right pixel \e
+in the cell. The other properties of the \a painter (pen, brush, etc) are
+undefined. \a cg is the color group to use. \a column is the
+logical column number within the item that is to be painted; 0 is
+the column which may contain a tree.
+This function may use Q3ListView::itemMargin() for readability
+spacing on the left and right sides of data such as text, and
+should honor \l isSelected() and
+Q3ListView::allColumnsShowFocus().
+If you reimplement this function, you should also reimplement \l
+width().
+The rectangle to be painted is in an undefined state when this
+function is called, so you \e must draw on all the pixels. The
+\a painter has the right font on entry.
+\sa paintBranches(), Q3ListView::drawContentsOffset()
+*/
+void Q3ListViewItem::paintCell(QPainter * p, const QColorGroup & cg,
+int column, int width, int align)
+{
+// Change width() if you change this.
+QPalette pal = cg;
+if (!p)
+return;
+Q3ListView *lv = listView();
+if (!lv)
+return;
+QFontMetrics fm(p->fontMetrics());
+// had, but we _need_ the column info for the ellipsis thingy!!!
+if (!columns) {
+for (int i = 0; i < lv->d->column.size(); ++i) {
+setText(i, text(i));
+}
+}
+QString t = text(column);
+if (columns) {
+Q3ListViewPrivate::ItemColumnInfo *ci = 0;
+// try until we have a column info....
+while (!ci) {
+ci = (Q3ListViewPrivate::ItemColumnInfo*)columns;
+for (int i = 0; ci && (i < column); ++i)
+ci = ci->next;
+if (!ci) {
+setText(column, t);
+ci = 0;
+}
+}
+// if the column width changed and this item was not painted since this change
+if (ci && (ci->width != width || ci->text != t || ci->dirty)) {
+ci->text = t;
+ci->dirty = false;
+ci->width = width;
+ci->truncated = false;
+// if we have to do the ellipsis thingy calc the truncated text
+int pw = lv->itemMargin()*2 - lv->d->minLeftBearing - lv->d->minRightBearing;
+pw += pixmap(column) ? pixmap(column)->width() + lv->itemMargin() : 0;
+if (!mlenabled && fm.width(t) + pw > width) {
+// take care of arabic shaping in width calculation (lars)
+ci->truncated = true;
+ci->tmpText = qEllipsisText(t, fm, width - pw, align);
+} else if (mlenabled && fm.width(t) + pw > width) {
+QStringList list = t.split(QLatin1Char('\n'));
+for (QStringList::Iterator it = list.begin(); it != list.end(); ++it) {
+QString z = *it;
+if (fm.width(z) + pw > width) {
+ci->truncated = true;
+*it = qEllipsisText(z, fm, width - pw, align);
+}
+}
+if (ci->truncated)
+ci->tmpText = list.join(QString(QLatin1Char('\n')));
+}
+}
+// if we have to draw the ellipsis thingy, use the truncated text
+if (ci && ci->truncated)
+t = ci->tmpText;
+}
+int marg = lv->itemMargin();
+int r = marg;
+const QPixmap * icon = pixmap(column);
+const QPalette::ColorRole crole = lv->viewport()->backgroundRole();
+if (pal.brush(crole) != lv->palette().brush(pal.currentColorGroup(), crole))
+p->fillRect(0, 0, width, height(), pal.brush(crole));
+else
+lv->paintEmptyArea(p, QRect(0, 0, width, height()));
+// (lars) what does this do???
+#if 0 // RS: ####
+if (align != Qt::AlignLeft)
+marg -= lv->d->minRightBearing;
+#endif
+if (isSelected() &&
+(column == 0 || lv->allColumnsShowFocus())) {
+p->fillRect(r - marg, 0, qMax(0, width - r + marg), height(),
+pal.brush(QPalette::Highlight));
+if (enabled || !lv)
+p->setPen(pal.highlightedText().color());
+else if (!enabled && lv)
+p->setPen(lv->palette().color(QPalette::Disabled, QPalette::HighlightedText));
+} else {
+if (enabled || !lv)
+p->setPen(pal.text().color());
+else if (!enabled && lv)
+p->setPen(lv->palette().color(QPalette::Disabled, QPalette::Text));
+}
+#if 0
+bool reverse = QApplication::reverseLayout();
+#else
+bool reverse = false;
+#endif
+int iconWidth = 0;
+if (icon) {
+iconWidth = icon->width() + lv->itemMargin();
+int xo = r;
+// we default to Qt::AlignVCenter.
+int yo = (height() - icon->height()) / 2;
+// I guess we may as well always respect vertical alignment.
+if (align & Qt::AlignBottom)
+yo = height() - icon->height();
+else if (align & Qt::AlignTop)
+yo = 0;
+// respect horizontal alignment when there is no text for an item.
+if (text(column).isEmpty()) {
+if (align & Qt::AlignRight)
+xo = width - 2 * marg - iconWidth;
+else if (align & Qt::AlignHCenter)
+xo = (width - iconWidth) / 2;
+}
+if (reverse)
+xo = width - 2 * marg - iconWidth;
+p->drawPixmap(xo, yo, *icon);
+}
+if (!t.isEmpty()) {
+if (!mlenabled) {
+if (!(align & Qt::AlignTop || align & Qt::AlignBottom))
+align |= Qt::AlignVCenter;
+} else {
+if (!(align & Qt::AlignVCenter || align & Qt::AlignBottom))
+align |= Qt::AlignTop;
+}
+if (!reverse)
+r += iconWidth;
+if (!mlenabled) {
+p->drawText(r, 0, width-marg-r, height(), align, t);
+} else {
+p->drawText(r, marg, width-marg-r, height(), align, t);
+}
+}
+if (mlenabled && column == 0 && isOpen() && childCount()) {
+int textheight = fm.size(align, t).height() + 2 * lv->itemMargin();
+textheight = qMax(textheight, QApplication::globalStrut().height());
+if (textheight % 2 > 0)
+textheight++;
+if (textheight < height()) {
+int w = lv->treeStepSize() / 2;
+QStyleOptionQ3ListView opt = getStyleOption(lv, this);
+opt.rect.setRect(0, textheight, w + 1, height() - textheight + 1);
+opt.palette = pal;
+opt.subControls = QStyle::SC_Q3ListViewExpand;
+opt.activeSubControls = QStyle::SC_All;
+lv->style()->drawComplexControl(QStyle::CC_Q3ListView, &opt, p, lv);
+}
+}
+}
+/*!
+Returns the number of pixels of width required to draw column \a c
+of list view \a lv, using the metrics \a fm without cropping. The
+list view containing this item may use this information depending
+on the Q3ListView::WidthMode settings for the column.
+The default implementation returns the width of the bounding
+rectangle of the text of column \a c.
+\sa listView() widthChanged() Q3ListView::setColumnWidthMode()
+Q3ListView::itemMargin()
+*/
+int Q3ListViewItem::width(const QFontMetrics& fm,
+const Q3ListView* lv, int c) const
+{
+int w;
+if (mlenabled)
+w = fm.size(Qt::AlignVCenter, text(c)).width() + lv->itemMargin() * 2
+- lv->d->minLeftBearing - lv->d->minRightBearing;
+else
+w = fm.width(text(c)) + lv->itemMargin() * 2
+- lv->d->minLeftBearing - lv->d->minRightBearing;
+const QPixmap * pm = pixmap(c);
+if (pm)
+w += pm->width() + lv->itemMargin(); // ### correct margin stuff?
+return qMax(w, QApplication::globalStrut().width());
+}
+/*!
+Paints a focus indicator on the rectangle \a r using painter \a p
+and colors \a cg.
+\a p is already clipped.
+\sa paintCell() paintBranches() Q3ListView::setAllColumnsShowFocus()
+*/
+void Q3ListViewItem::paintFocus(QPainter *p, const QColorGroup &cg, const QRect &r)
+{
+QPalette pal = cg;
+Q3ListView *lv = listView();
+if (lv) {
+QStyleOptionFocusRect opt;
+opt.init(lv);
+opt.rect = r;
+opt.palette = pal;
+opt.state |= QStyle::State_KeyboardFocusChange;
+if (isSelected()) {
+opt.state |= QStyle::State_FocusAtBorder;
+opt.backgroundColor = pal.highlight().color();
+} else {
+opt.state |= QStyle::State_None;
+opt.backgroundColor = pal.base().color();
+}
+lv->style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p, lv);
+}
+}
+/*!
+Paints a set of branches from this item to (some of) its children.
+Painter \a p is set up with clipping and translation so that you
+can only draw in the rectangle that needs redrawing; \a cg is the
+color group to use; the update rectangle is at (0, 0) and has size
+width \a w by height \a h. The top of the rectangle you own is at
+\a y (which is never greater than 0 but can be outside the window
+system's allowed coordinate range).
+The update rectangle is in an undefined state when this function
+is called; this function must draw on \e all of the pixels.
+\sa paintCell(), Q3ListView::drawContentsOffset()
+*/
+void Q3ListViewItem::paintBranches(QPainter * p, const QColorGroup & cg,
+int w, int y, int h)
+{
+Q3ListView *lv = listView();
+if (lv)
+lv->paintEmptyArea(p, QRect(0, 0, w, h));
+if (!visible || !lv)
+return;
+QStyleOptionQ3ListView opt = getStyleOption(lv, this, true);
+opt.rect.setRect(0, y, w, h);
+opt.palette = cg;
+opt.subControls = QStyle::SC_Q3ListViewBranch | QStyle::SC_Q3ListViewExpand;
+opt.activeSubControls = QStyle::SC_None;
+lv->style()->drawComplexControl(QStyle::CC_Q3ListView, &opt, p, lv);
+}
+Q3ListViewPrivate::Root::Root(Q3ListView * parent)
+: Q3ListViewItem(parent)
+{
+lv = parent;
+setHeight(0);
+setOpen(true);
+}
+void Q3ListViewPrivate::Root::setHeight(int)
+{
+Q3ListViewItem::setHeight(0);
+}
+void Q3ListViewPrivate::Root::invalidateHeight()
+{
+Q3ListViewItem::invalidateHeight();
+lv->triggerUpdate();
+}
+Q3ListView * Q3ListViewPrivate::Root::theListView() const
+{
+return lv;
+}
+void Q3ListViewPrivate::Root::setup()
+{
+// explicitly nothing
+}
+/*!
+\internal
+If called after a mouse click, tells the list view to ignore a
+following double click. This state is reset after the next mouse click.
+*/
+void Q3ListViewItem::ignoreDoubleClick()
+{
+Q3ListView *lv = listView();
+if (lv)
+lv->d->ignoreDoubleClick = true;
+}
+/*!
+\fn void  Q3ListView::onItem(Q3ListViewItem *i)
+This signal is emitted when the user moves the mouse cursor onto
+item \a i, similar to the QWidget::enterEvent() function.
+*/
+// ### bug here too? see qiconview.cppp onItem/onViewport
+/*!
+\fn void  Q3ListView::onViewport()
+This signal is emitted when the user moves the mouse cursor from
+an item to an empty part of the list view.
+*/
+/*!
+\enum Q3ListView::SelectionMode
+This enumerated type is used by Q3ListView to indicate how it
+reacts to selection by the user.
+\value Single  When the user selects an item, any already-selected
+item becomes unselected, and the user cannot unselect the selected
+item.
+\value Multi  When the user selects an item in the usual way, the
+selection status of that item is toggled and the other items are
+left alone.
+\value Extended When the user selects an item in the usual way,
+the selection is cleared and the new item selected. However, if
+the user presses the Ctrl key when clicking on an item, the
+clicked item gets toggled and all other items are left untouched.
+And if the user presses the Shift key while clicking on an item,
+all items between the current item and the clicked item get
+selected or unselected, depending on the state of the clicked
+item. Also, multiple items can be selected by dragging the mouse
+over them.
+\value NoSelection  Items cannot be selected.
+In other words, \c Single is a real single-selection list view, \c
+Multi a real multi-selection list view, \c Extended is a list view
+where users can select multiple items but usually want to select
+either just one or a range of contiguous items, and \c NoSelection
+is a list view where the user can look but not touch.
+*/
+/*!
+\enum Q3ListView::ResizeMode
+This enum describes how the list view's header adjusts to resize
+events which affect the width of the list view.
+\value NoColumn The columns do not get resized in resize events.
+\value AllColumns All columns are resized equally to fit the width
+of the list view.
+\value LastColumn The last column is resized to fit the width of
+the list view.
+*/
+/*!
+\enum Q3ListView::RenameAction
+This enum describes whether a rename operation is accepted if the
+rename editor loses focus without the user pressing Enter.
+\value Accept Rename if Enter is pressed or focus is lost.
+\value Reject Discard the rename operation if focus is lost (and
+Enter has not been pressed).
+*/
+/*!
+\class Q3ListView
+\brief The Q3ListView class implements a list/tree view.
+\compat
+It can display and control a hierarchy of multi-column items, and
+provides the ability to add new items at any time. The user may
+select one or many items (depending on the \c SelectionMode) and
+sort the list in increasing or decreasing order by any column.
+The simplest pattern of use is to create a Q3ListView, add some
+column headers using addColumn() and create one or more
+Q3ListViewItem or Q3CheckListItem objects with the Q3ListView as
+parent.
+Further nodes can be added to the list view object (the root of the
+tree) or as child nodes to Q3ListViewItems.
+The main setup functions are:
+\table
+\header \i Function \i Action
+\row \i \l addColumn()
+\i Adds a column with a text label and perhaps width. Columns
+are counted from the left starting with column 0.
+\row \i \l setColumnWidthMode()
+\i Sets the column to be resized automatically or not.
+\row \i \l setAllColumnsShowFocus()
+\i Sets whether items should show keyboard focus using all
+columns or just column 0. The default is to show focus
+just using column 0.
+\row \i \l setRootIsDecorated()
+\i Sets whether root items can be opened and closed by the
+user and have open/close decoration to their left. The
+default is false.
+\row \i \l setTreeStepSize()
+\i Sets how many pixels an item's children are indented
+relative to their parent. The default is 20. This is
+mostly a matter of taste.
+\row \i \l setSorting()
+\i Sets whether the items should be sorted, whether it should
+be in ascending or descending order, and by what column
+they should be sorted. By default the list view is sorted
+by the first column; to switch this off call setSorting(-1).
+\endtable
+There are several functions for mapping between items and
+coordinates. itemAt() returns the item at a position on-screen,
+itemRect() returns the rectangle an item occupies on the screen,
+and itemPos() returns the position of any item (whether it is
+on-screen or not). firstChild() returns the list view's first item
+(not necessarily visible on-screen).
+You can iterate over visible items using
+Q3ListViewItem::itemBelow(); over a list view's top-level items
+using Q3ListViewItem::firstChild() and
+Q3ListViewItem::nextSibling(); or every item using a
+Q3ListViewItemIterator. See
+the Q3ListViewItem documentation for examples of traversal.
+An item can be moved amongst its siblings using
+Q3ListViewItem::moveItem(). To move an item in the hierarchy use
+takeItem() and insertItem(). Item's (and all their child items)
+are deleted with \c delete; to delete all the list view's items
+use clear().
+There are a variety of selection modes described in the
+Q3ListView::SelectionMode documentation. The default is \c Single
+selection, which you can change using setSelectionMode().
+Because Q3ListView offers multiple selection it must display
+keyboard focus and selection state separately. Therefore there are
+functions both to set the selection state of an item
+(setSelected()) and to set which item displays keyboard focus
+(setCurrentItem()).
+Q3ListView emits two groups of signals; one group signals changes
+in selection/focus state and one indicates selection. The first
+group consists of selectionChanged() (applicable to all list
+views), selectionChanged(Q3ListViewItem*) (applicable only to a
+\c Single selection list view), and currentChanged(Q3ListViewItem*).
+The second group consists of doubleClicked(Q3ListViewItem*),
+returnPressed(Q3ListViewItem*),
+rightButtonClicked(Q3ListViewItem*, const QPoint&, int), etc.
+Note that changing the state of the list view in a slot connected
+to a list view signal may cause unexpected side effects. If you
+need to change the list view's state in response to a signal, use
+a \link QTimer::singleShot() single shot timer\endlink with a
+time out of 0, and connect this timer to a slot that modifies the
+list view's state.
+In Motif style, Q3ListView deviates fairly strongly from the look
+and feel of the Motif hierarchical tree view. This is done mostly
+to provide a usable keyboard interface and to make the list view
+look better with a white background.
+If selectionMode() is \c Single (the default) the user can select
+one item at a time, e.g. by clicking an item with the mouse, see
+\l Q3ListView::SelectionMode for details.
+The list view can be navigated either using the mouse or the
+keyboard. Clicking a \bold{-} icon closes an item (hides its
+children) and clicking a \bold{+} icon opens an item (shows its
+children). The keyboard controls are these:
+\table
+\header \i Keypress \i Action
+\row \i Home
+\i Make the first item current and visible.
+\row \i End
+\i Make the last item current and visible.
+\row \i Page Up
+\i Make the item above the top visible item current and visible.
+\row \i Page Down
+\i Make the item below the bottom visible item current and visible.
+\row \i Up Arrow
+\i Make the item above the current item current and visible.
+\row \i Down Arrow
+\i Make the item below the current item current and visible.
+\row \i Left Arrow
+\i If the current item is closed (\bold{+} icon) or has no
+children, make its parent item current and visible. If the
+current item is open (\bold{-} icon) close it, i.e. hide its
+children. Exception: if the current item is the first item
+and is closed and the horizontal scroll bar is offset to
+the right the list view will be scrolled left.
+\row \i Right Arrow
+\i If the current item is closed (\bold{+} icon) and has
+children, the item is opened. If the current item is
+opened (\bold{-} icon) and has children the item's first
+child is made current and visible. If the current item has
+no children the list view is scrolled right.
+\endtable
+If the user starts typing letters with the focus in the list view
+an incremental search will occur. For example if the user types
+'d' the current item will change to the first item that begins
+with the letter 'd'; if they then type 'a', the current item will
+change to the first item that begins with 'da', and so on. If no
+item begins with the letters they type the current item doesn't
+change.
+Note that the list view's size hint is calculated taking into
+account the height \e and width to produce a nice aspect ratio.
+This may mean that you need to reimplement sizeHint() in some
+cases.
+\warning The list view assumes ownership of all list view items
+and will delete them when it does not need them any more.
+\sa Q3ListViewItem Q3CheckListItem
+*/
+/*!
+\fn void Q3ListView::itemRenamed(Q3ListViewItem * item, int col)
+\overload
+This signal is emitted when \a item has been renamed, e.g. by
+in-place renaming, in column \a col.
+\sa Q3ListViewItem::setRenameEnabled()
+*/
+/*!
+\fn void Q3ListView::itemRenamed(Q3ListViewItem * item, int col, const QString &text)
+This signal is emitted when \a item has been renamed to \a text,
+e.g. by in in-place renaming, in column \a col.
+\sa Q3ListViewItem::setRenameEnabled()
+*/
+/*!
+Constructs a new empty list view called \a name with parent \a
+parent and widget attributes \a f.
+This constructor sets the \c WA_StaticContent and the \c
+Qt::WA_NoBackground attributes to boost performance when drawing
+Q3ListViewItems. This may be unsuitable for custom Q3ListViewItem
+classes, in which case Qt::WA_StaticContents and Qt::WA_NoBackground
+should be cleared on the viewport() after construction.
+\sa QWidget::setAttribute()
+*/
+Q3ListView::Q3ListView(QWidget * parent, const char *name, Qt::WindowFlags f)
+: Q3ScrollView(parent, name, f | Qt::WStaticContents | Qt::WNoAutoErase)
+{
+init();
+}
+void Q3ListView::init()
+{
+d = new Q3ListViewPrivate;
+d->vci = 0;
+d->timer = new QTimer(this);
+d->levelWidth = 20;
+d->r = 0;
+d->rootIsExpandable = 0;
+d->h = new Q3Header(this, "list view header");
+d->h->installEventFilter(this);
+d->focusItem = 0;
+d->oldFocusItem = 0;
+d->dirtyItemTimer = new QTimer(this);
+d->visibleTimer = new QTimer(this);
+d->renameTimer = new QTimer(this);
+d->autoopenTimer = new QTimer(this);
+d->margin = 1;
+d->selectionMode = Q3ListView::Single;
+d->sortcolumn = 0;
+d->ascending = true;
+d->allColumnsShowFocus = false;
+d->fontMetricsHeight = fontMetrics().height();
+d->h->setTracking(true);
+d->buttonDown = false;
+d->ignoreDoubleClick = false;
+d->scrollTimer = 0;
+d->sortIndicator = false;
+d->clearing = false;
+d->minLeftBearing = fontMetrics().minLeftBearing();
+d->minRightBearing = fontMetrics().minRightBearing();
+d->ellipsisWidth = fontMetrics().width(QLatin1String("...")) * 2;
+d->highlighted = 0;
+d->pressedItem = 0;
+d->selectAnchor = 0;
+d->select = true;
+d->startDragItem = 0;
+d->toolTips = true;
+d->updateHeader = false;
+d->fullRepaintOnComlumnChange = false;
+d->resizeMode = NoColumn;
+d->defRenameAction = Reject;
+d->pressedEmptyArea = false;
+d->startEdit = true;
+d->ignoreEditAfterFocus = false;
+d->inMenuMode = false;
+d->pressedSelected = false;
+setMouseTracking(true);
+viewport()->setMouseTracking(true);
+connect(d->timer, SIGNAL(timeout()),
+this, SLOT(updateContents()));
+connect(d->dirtyItemTimer, SIGNAL(timeout()),
+this, SLOT(updateDirtyItems()));
+connect(d->visibleTimer, SIGNAL(timeout()),
+this, SLOT(makeVisible()));
+connect(d->renameTimer, SIGNAL(timeout()),
+this, SLOT(startRename()));
+connect(d->autoopenTimer, SIGNAL(timeout()),
+this, SLOT(openFocusItem()));
+connect(d->h, SIGNAL(sizeChange(int,int,int)),
+this, SLOT(handleSizeChange(int,int,int)));
+connect(d->h, SIGNAL(indexChange(int,int,int)),
+this, SLOT(handleIndexChange()));
+connect(d->h, SIGNAL(sectionClicked(int)),
+this, SLOT(changeSortColumn(int)));
+connect(d->h, SIGNAL(sectionHandleDoubleClicked(int)),
+this, SLOT(adjustColumn(int)));
+connect(horizontalScrollBar(), SIGNAL(sliderMoved(int)),
+d->h, SLOT(setOffset(int)));
+connect(horizontalScrollBar(), SIGNAL(valueChanged(int)),
+d->h, SLOT(setOffset(int)));
+// will access d->r
+Q3ListViewPrivate::Root * r = new Q3ListViewPrivate::Root(this);
+r->is_root = true;
+d->r = r;
+d->r->setSelectable(false);
+viewport()->setFocusProxy(this);
+viewport()->setFocusPolicy(Qt::WheelFocus);
+setFocusPolicy(Qt::WheelFocus);
+viewport()->setBackgroundRole(QPalette::Base);
+setAttribute(Qt::WA_MacShowFocusRect);
+}
+/*!
+\property Q3ListView::showSortIndicator
+\brief whether the list view header should display a sort indicator.
+If this property is true, an arrow is drawn in the header of the
+list view to indicate the sort order of the list view contents.
+The arrow will be drawn in the correct column and will point up or
+down, depending on the current sort direction. The default is
+false (don't show an indicator).
+\sa Q3Header::setSortIndicator()
+*/
+void Q3ListView::setShowSortIndicator(bool show)
+{
+if (show == d->sortIndicator)
+return;
+d->sortIndicator = show;
+if (d->sortcolumn != Unsorted && d->sortIndicator)
+d->h->setSortIndicator(d->sortcolumn, d->ascending);
+else
+d->h->setSortIndicator(-1);
+}
+bool Q3ListView::showSortIndicator() const
+{
+return d->sortIndicator;
+}
+/*!
+\property Q3ListView::showToolTips
+\brief whether this list view should show tooltips for truncated column texts
+The default is true.
+*/
+void Q3ListView::setShowToolTips(bool b)
+{
+d->toolTips = b;
+}
+bool Q3ListView::showToolTips() const
+{
+return d->toolTips;
+}
+/*!
+\property Q3ListView::resizeMode
+\brief whether all, none or the only the last column should be resized
+Specifies whether all, none or only the last column should be
+resized to fit the full width of the list view. The values for this
+property can be one of: \c NoColumn (the default), \c AllColumns
+or \c LastColumn.
+\warning Setting the resize mode should be done after all necessary
+columns have been added to the list view, otherwise the behavior is
+undefined.
+\sa Q3Header, header()
+*/
+void Q3ListView::setResizeMode(ResizeMode m)
+{
+d->resizeMode = m;
+if (m == NoColumn)
+header()->setStretchEnabled(false);
+else if (m == AllColumns)
+header()->setStretchEnabled(true);
+else
+header()->setStretchEnabled(true, header()->count() - 1);
+}
+Q3ListView::ResizeMode Q3ListView::resizeMode() const
+{
+return d->resizeMode;
+}
+/*!
+Destroys the list view, deleting all its items, and frees up all
+allocated resources.
+*/
+Q3ListView::~Q3ListView()
+{
+for (int j = 0; j < d->iterators.size(); ++j) {
+Q3ListViewItemIterator *i = d->iterators.at(j);
+i->listView = 0;
+}
+d->focusItem = 0;
+delete d->r;
+d->r = 0;
+delete d->vci;
+d->vci = 0;
+#if 0
+delete d->toolTip;
+d->toolTip = 0;
+#endif
+delete d;
+d = 0;
+}
+/*!
+Calls Q3ListViewItem::paintCell() and
+Q3ListViewItem::paintBranches() as necessary for all list view
+items that require repainting in the \a cw pixels wide and \a ch
+pixels high bounding rectangle starting at position \a cx, \a cy
+with offset \a ox, \a oy. Uses the painter \a p.
+*/
+void Q3ListView::drawContentsOffset(QPainter * p, int ox, int oy,
+int cx, int cy, int cw, int ch)
+{
+if (columns() == 0) {
+paintEmptyArea(p, QRect(cx, cy, cw, ch));
+return;
+}
+if (d->drawables.isEmpty() ||
+d->topPixel > cy ||
+d->bottomPixel < cy + ch - 1 ||
+d->r->maybeTotalHeight < 0)
+buildDrawableList();
+if (!d->dirtyItems.isEmpty()) {
+QRect br(cx - ox, cy - oy, cw, ch);
+for (int i = 0; i < d->dirtyItems.size(); ++i) {
+const Q3ListViewItem * item = d->dirtyItems.at(i);
+QRect ir = itemRect(item).intersected(viewport()->visibleRect());
+if (ir.isEmpty() || br.contains(ir))
+// we're painting this one, or it needs no painting: forget it
+d->dirtyItems.removeAt(i);
+}
+if (d->dirtyItems.count()) {
+// there are still items left that need repainting
+d->dirtyItemTimer->start(0, true);
+} else {
+// we're painting all items that need to be painted
+d->dirtyItems.clear();
+d->dirtyItemTimer->stop();
+}
+}
+p->setFont(font());
+QRect r;
+int fx = -1, x, fc = 0, lc = 0;
+int tx = -1;
+for (int i = 0; i < d->drawables.size(); ++i) {
+Q3ListViewPrivate::DrawableItem current = d->drawables.at(i);
+if (!current.i->isVisible())
+continue;
+int ih = current.i->height();
+int ith = current.i->totalHeight();
+int c;
+int cs;
+// need to paint current?
+if (ih > 0 && current.y < cy+ch && current.y+ih > cy) {
+if (fx < 0) {
+// find first interesting column, once
+x = 0;
+c = 0;
+cs = d->h->cellSize(0);
+while (x + cs <= cx && c < d->h->count()) {
+x += cs;
+c++;
+if (c < d->h->count())
+cs = d->h->cellSize(c);
+}
+fx = x;
+fc = c;
+while(x < cx + cw && c < d->h->count()) {
+x += cs;
+c++;
+if (c < d->h->count())
+cs = d->h->cellSize(c);
+}
+lc = c;
+}
+x = fx;
+c = fc;
+// draw to last interesting column
+bool drawActiveSelection = hasFocus() || d->inMenuMode ||
+!style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)
+|| (currentItem() && currentItem()->renameBox
+&& currentItem()->renameBox->hasFocus());
+QPalette pal = palette();
+if(!drawActiveSelection)
+pal.setCurrentColorGroup(QPalette::Inactive);
+while (c < lc) {
+int i = d->h->mapToLogical(c);
+cs = d->h->cellSize(c);
+r.setRect(x - ox, current.y - oy, cs, ih);
+if (i == 0 && current.i->parentItem)
+r.setLeft(r.left() + current.l * treeStepSize());
+p->save();
+// No need to paint if the cell isn't technically visible
+if (!(r.width() == 0 || r.height() == 0)) {
+p->translate(r.left(), r.top());
+int ac = d->h->mapToLogical(c);
+// map to Left currently. This should change once we
+// can really reverse the listview.
+int align = columnAlignment(ac);
+if (align == Qt::AlignAuto) align = Qt::AlignLeft;
+current.i->paintCell(p, pal, ac, r.width(), align);
+}
+p->restore();
+x += cs;
+c++;
+}
+if (current.i == d->focusItem && hasFocus() &&
+!d->allColumnsShowFocus) {
+p->save();
+int cell = d->h->mapToActual(0);
+QRect r(d->h->cellPos(cell) - ox, current.y - oy, d->h->cellSize(cell), ih);
+if (current.i->parentItem)
+r.setLeft(r.left() + current.l * treeStepSize());
+if (r.left() < r.right())
+current.i->paintFocus(p, palette(), r);
+p->restore();
+}
+}
+const int cell = d->h->mapToActual(0);
+// does current need focus indication?
+if (current.i == d->focusItem && hasFocus() &&
+d->allColumnsShowFocus) {
+p->save();
+int x = -contentsX();
+int w = header()->cellPos(header()->count() - 1) +
+header()->cellSize(header()->count() - 1);
+r.setRect(x, current.y - oy, w, ih);
+if (d->h->mapToActual(0) == 0 || (current.l == 0 && !rootIsDecorated())) {
+int offsetx = qMin(current.l * treeStepSize(), d->h->cellSize(cell));
+r.setLeft(r.left() + offsetx);
+current.i->paintFocus(p, palette(), r);
+} else {
+int xdepth = qMin(treeStepSize() * (current.i->depth() + (rootIsDecorated() ? 1 : 0))
++ itemMargin(), d->h->cellSize(cell));
+xdepth += d->h->cellPos(cell);
+QRect r1(r);
+r1.setRight(d->h->cellPos(cell) - 1);
+QRect r2(r);
+r2.setLeft(xdepth - 1);
+current.i->paintFocus(p, palette(), r1);
+current.i->paintFocus(p, palette(), r2);
+}
+p->restore();
+}
+if (tx < 0)
+tx = d->h->cellPos(cell);
+// do any children of current need to be painted?
+if (ih != ith &&
+(current.i != d->r || d->rootIsExpandable) &&
+current.y + ith > cy &&
+current.y + ih < cy + ch &&
+tx + current.l * treeStepSize() < cx + cw &&
+tx + (current.l+1) * treeStepSize() > cx) {
+// compute the clip rectangle the safe way
+int rtop = current.y + ih;
+int rbottom = current.y + ith;
+int rleft = tx + current.l*treeStepSize();
+int rright = rleft + treeStepSize();
+int crtop = qMax(rtop, cy);
+int crbottom = qMin(rbottom, cy+ch);
+int crleft = qMax(rleft, cx);
+int crright = qMin(rright, cx+cw);
+r.setRect(crleft-ox, crtop-oy,
+crright-crleft, crbottom-crtop);
+if (r.isValid()) {
+p->save();
+p->setClipRect(QRect(d->h->cellPos(cell), 0, d->h->cellSize(cell), height()));
+p->translate(rleft-ox, crtop-oy);
+current.i->paintBranches(p, palette(), treeStepSize(),
+rtop - crtop, r.height());
+p->restore();
+}
+}
+}
+if (d->r->totalHeight() < cy + ch)
+paintEmptyArea(p, QRect(cx - ox, d->r->totalHeight() - oy,
+cw, cy + ch - d->r->totalHeight()));
+int c = d->h->count()-1;
+if (c >= 0 &&
+d->h->cellPos(c) + d->h->cellSize(c) < cx + cw) {
+c = d->h->cellPos(c) + d->h->cellSize(c);
+paintEmptyArea(p, QRect(c - ox, cy - oy, cx + cw - c, ch));
+}
+}
+/*!
+Paints \a rect so that it looks like empty background using
+painter \a p. \a rect is in widget coordinates, ready to be fed to
+\a p.
+The default function fills \a rect with the
+viewport()->backgroundBrush().
+*/
+void Q3ListView::paintEmptyArea(QPainter * p, const QRect & rect)
+{
+QStyleOptionQ3ListView opt = getStyleOption(this, 0);
+opt.rect = rect;
+opt.sortColumn = d->sortcolumn;
+opt.subControls = QStyle::SC_Q3ListView;
+style()->drawComplexControl(QStyle::CC_Q3ListView, &opt, p, this);
+}
+/*
+Rebuilds the list of drawable Q3ListViewItems. This function is
+const so that const functions can call it without requiring
+d->drawables to be mutable.
+*/
+void Q3ListView::buildDrawableList() const
+{
+d->r->enforceSortOrder();
+QStack<Q3ListViewPrivate::DrawableItem> stack;
+Q3ListViewPrivate::DrawableItem di(((int)d->rootIsExpandable)-1, 0, d->r);
+stack.push(di);
+Q3ListView *that = const_cast<Q3ListView *>(this);
+// could mess with cy and ch in order to speed up vertical
+// scrolling
+int cy = contentsY();
+int ch = that->visibleHeight();
+d->topPixel = cy + ch; // one below bottom
+d->bottomPixel = cy - 1; // one above top
+that->d->drawables.clear();
+while (!stack.isEmpty()) {
+Q3ListViewPrivate::DrawableItem cur = stack.pop();
+int ih = cur.i->height();
+int ith = cur.i->totalHeight();
+// is this item, or its branch symbol, inside the viewport?
+if (cur.y + ith >= cy && cur.y < cy + ch) {
+that->d->drawables.append(cur);
+// perhaps adjust topPixel up to this item?  may be adjusted
+// down again if any children are not to be painted
+if (cur.y < d->topPixel)
+d->topPixel = cur.y;
+// bottompixel is easy: the bottom item drawn contains it
+d->bottomPixel = cur.y + ih - 1;
+}
+// push younger sibling of cur on the stack?
+if (cur.y + ith < cy+ch && cur.i->siblingItem)
+stack.push(Q3ListViewPrivate::DrawableItem(cur.l, cur.y + ith, cur.i->siblingItem));
+// do any children of cur need to be painted?
+if (cur.i->isOpen() && cur.i->childCount() &&
+cur.y + ith > cy &&
+cur.y + ih < cy + ch) {
+cur.i->enforceSortOrder();
+Q3ListViewItem * c = cur.i->childItem;
+int y = cur.y + ih;
+// if any of the children are not to be painted, skip them
+// and invalidate topPixel
+while (c && y + c->totalHeight() <= cy) {
+y += c->totalHeight();
+c = c->siblingItem;
+d->topPixel = cy + ch;
+}
+// push one child on the stack, if there is at least one
+// needing to be painted
+if (c && y < cy+ch)
+stack.push(Q3ListViewPrivate::DrawableItem(cur.l + 1, y, c));
+}
+}
+}
+/*!
+\property Q3ListView::treeStepSize
+\brief the number of pixels a child is offset from its parent
+The default is 20 pixels.
+Of course, this property is only meaningful for hierarchical list
+views.
+*/
+int Q3ListView::treeStepSize() const
+{
+return d->levelWidth;
+}
+void Q3ListView::setTreeStepSize(int size)
+{
+if (size != d->levelWidth) {
+d->levelWidth = size;
+viewport()->repaint();
+}
+}
+/*!
+Inserts item \a i into the list view as a top-level item. You do
+not need to call this unless you've called takeItem(\a i) or
+Q3ListViewItem::takeItem(\a i) and need to reinsert \a i elsewhere.
+\sa Q3ListViewItem::takeItem() takeItem()
+*/
+void Q3ListView::insertItem(Q3ListViewItem * i)
+{
+if (d->r) // not for d->r itself
+d->r->insertItem(i);
+}
+/*!
+Removes and deletes all the items in this list view and triggers
+an update.
+\sa triggerUpdate()
+*/
+void Q3ListView::clear()
+{
+bool wasUpdatesEnabled = viewport()->updatesEnabled();
+if (wasUpdatesEnabled)
+viewport()->setUpdatesEnabled(false);
+setContentsPos(0, 0);
+if (wasUpdatesEnabled)
+viewport()->setUpdatesEnabled(true);
+bool block = signalsBlocked();
+blockSignals(true);
+d->clearing = true;
+clearSelection();
+for (int j = 0; j < d->iterators.size(); ++j) {
+Q3ListViewItemIterator *i = d->iterators.at(j);
+i->curr = 0;
+}
+d->drawables.clear();
+d->dirtyItems.clear();
+d->dirtyItemTimer->stop();
+d->highlighted = 0;
+d->focusItem = 0;
+d->selectAnchor = 0;
+d->pressedItem = 0;
+d->startDragItem = 0;
+// if it's down its downness makes no sense, so undown it
+d->buttonDown = false;
+Q3ListViewItem *c = (Q3ListViewItem *)d->r->firstChild();
+Q3ListViewItem *n;
+while(c) {
+n = (Q3ListViewItem *)c->nextSibling();
+delete c;
+c = n;
+}
+resizeContents(d->h->sizeHint().width(), contentsHeight());
+delete d->r;
+d->r = 0;
+Q3ListViewPrivate::Root * r = new Q3ListViewPrivate::Root(this);
+r->is_root = true;
+d->r = r;
+d->r->setSelectable(false);
+blockSignals(block);
+triggerUpdate();
+d->clearing = false;
+}
+/*!
+\reimp
+*/
+void Q3ListView::setContentsPos(int x, int y)
+{
+updateGeometries();
+Q3ScrollView::setContentsPos(x, y);
+}
+/*!
+Adds a \a width pixels wide column with the column header \a label
+to the list view, and returns the index of the new column.
+All columns apart from the first one are inserted to the right of
+the existing ones.
+If \a width is negative, the new column's \l WidthMode is set to
+\c Maximum instead of \c Manual.
+\sa setColumnText() setColumnWidth() setColumnWidthMode()
+*/
+int Q3ListView::addColumn(const QString &label, int width)
+{
+int c = d->h->addLabel(label, width);
+d->column.resize(c+1);
+d->column[c].wmode = (width >= 0 ? Manual : Maximum);
+updateGeometries();
+updateGeometry();
+return c;
+}
+/*!
+\overload
+Adds a \a width pixels wide new column with the header \a label
+and the \a icon to the list view, and returns the index of the
+column.
+If \a width is negative, the new column's \l WidthMode is set to
+\c Maximum, and to \c Manual otherwise.
+\sa setColumnText() setColumnWidth() setColumnWidthMode()
+*/
+int Q3ListView::addColumn(const QIcon& icon, const QString &label, int width)
+{
+int c = d->h->addLabel(icon, label, width);
+d->column.resize(c+1);
+d->column[c].wmode = (width >= 0 ? Manual : Maximum);
+updateGeometries();
+updateGeometry();
+return c;
+}
+/*!
+\property Q3ListView::columns
+\brief the number of columns in this list view
+\sa addColumn(), removeColumn()
+*/
+int Q3ListView::columns() const
+{
+return d->column.count();
+}
+/*!
+Removes the column at position \a index.
+*/
+void Q3ListView::removeColumn(int index)
+{
+if (index < 0 || index > (int)d->column.count() - 1)
+return;
+if (d->vci) {
+Q3ListViewPrivate::ViewColumnInfo *vi = d->vci, *prev = 0, *next = 0;
+for (int i = 0; i < index; ++i) {
+if (vi) {
+prev = vi;
+vi = vi->next;
+}
+}
+if (vi) {
+next = vi->next;
+if (prev)
+prev->next = next;
+vi->next = 0;
+delete vi;
+if (index == 0)
+d->vci = next;
+}
+}
+Q3ListViewItemIterator it(this);
+for (; it.current(); ++it) {
+Q3ListViewPrivate::ItemColumnInfo *ci = (Q3ListViewPrivate::ItemColumnInfo*)it.current()->columns;
+if (ci) {
+Q3ListViewPrivate::ItemColumnInfo *prev = 0, *next = 0;
+for (int i = 0; i < index; ++i) {
+if (ci) {
+prev = ci;
+ci = ci->next;
+}
+}
+if (ci) {
+next = ci->next;
+if (prev)
+prev->next = next;
+ci->next = 0;
+delete ci;
+if (index == 0)
+it.current()->columns = next;
+}
+}
+}
+for (int i = index; i < (int)d->column.size() - 1; ++i)
+d->column[i] = d->column[i + 1];
+d->column.resize(d->column.size() - 1);
+d->h->removeLabel(index);
+if (d->resizeMode == LastColumn)
+d->h->setStretchEnabled(true, d->h->count() - 1);
+updateGeometries();
+if (d->column.count() == 0)
+clear();
+updateGeometry();
+viewport()->update();
+}
+/*!
+Sets the heading of column \a column to \a label.
+\sa columnText()
+*/
+void Q3ListView::setColumnText(int column, const QString &label)
+{
+if (column < d->h->count()) {
+d->h->setLabel(column, label);
+updateGeometries();
+updateGeometry();
+}
+}
+/*!
+\overload
+Sets the heading of column \a column to \a icon and \a label.
+\sa columnText()
+*/
+void Q3ListView::setColumnText(int column, const QIcon& icon, const QString &label)
+{
+if (column < d->h->count()) {
+d->h->setLabel(column, icon, label);
+updateGeometries();
+}
+}
+/*!
+Sets the width of column \a column to \a w pixels. Note that if
+the column has a \c WidthMode other than \c Manual, this width
+setting may be subsequently overridden.
+\sa columnWidth()
+*/
+void Q3ListView::setColumnWidth(int column, int w)
+{
+int oldw = d->h->sectionSize(column);
+if (column < d->h->count() && oldw != w) {
+d->h->resizeSection(column, w);
+disconnect(d->h, SIGNAL(sizeChange(int,int,int)),
+this, SLOT(handleSizeChange(int,int,int)));
+emit d->h->sizeChange(column, oldw, w);
+connect(d->h, SIGNAL(sizeChange(int,int,int)),
+this, SLOT(handleSizeChange(int,int,int)));
+viewport()->update();
+}
+}
+/*!
+Returns the text of column \a c.
+\sa setColumnText()
+*/
+QString Q3ListView::columnText(int c) const
+{
+return d->h->label(c);
+}
+/*!
+Returns the width of column \a c.
+\sa setColumnWidth()
+*/
+int Q3ListView::columnWidth(int c) const
+{
+int actual = d->h->mapToActual(c);
+return d->h->cellSize(actual);
+}
+/*!
+\enum Q3ListView::WidthMode
+This enum type describes how the width of a column in the view
+changes.
+\value Manual the column width does not change automatically.
+\value Maximum  the column is automatically sized according to the
+widths of all items in the column. (Note: The column never shrinks
+in this case.) This means that the column is always resized to the
+width of the item with the largest width in the column.
+\sa setColumnWidth() setColumnWidthMode() columnWidth()
+*/
+/*!
+Sets column \a{c}'s width mode to \a mode. The default depends on
+the original width argument to addColumn().
+\sa Q3ListViewItem::width()
+*/
+void Q3ListView::setColumnWidthMode(int c, WidthMode mode)
+{
+if (c >= 0 && c < d->h->count())
+d->column[c].wmode = mode;
+}
+/*!
+Returns the \c WidthMode for column \a c.
+\sa setColumnWidthMode()
+*/
+Q3ListView::WidthMode Q3ListView::columnWidthMode(int c) const
+{
+if (c >= 0 && c < d->h->count())
+return d->column[c].wmode;
+else
+return Manual;
+}
+/*!
+Sets column \a{column}'s alignment to \a align. The alignment is
+ultimately passed to Q3ListViewItem::paintCell() for each item in
+the list view. For horizontally aligned text with Qt::AlignLeft or
+Qt::AlignHCenter the ellipsis (...) will be to the right, for
+Qt::AlignRight the ellipsis will be to the left.
+\sa Qt::Alignment
+*/
+void Q3ListView::setColumnAlignment(int column, int align)
+{
+if (column < 0)
+return;
+if (!d->vci)
+d->vci = new Q3ListViewPrivate::ViewColumnInfo;
+Q3ListViewPrivate::ViewColumnInfo * l = d->vci;
+while(column) {
+if (!l->next)
+l->next = new Q3ListViewPrivate::ViewColumnInfo;
+l = l->next;
+column--;
+}
+if (l->align == align)
+return;
+l->align = align;
+triggerUpdate();
+}
+/*!
+Returns the alignment of column \a column. The default is \c
+Qt::AlignAuto.
+\sa Qt::Alignment
+*/
+int Q3ListView::columnAlignment(int column) const
+{
+if (column < 0 || !d->vci)
+return Qt::AlignAuto;
+Q3ListViewPrivate::ViewColumnInfo * l = d->vci;
+while(column) {
+if (!l->next)
+l->next = new Q3ListViewPrivate::ViewColumnInfo;
+l = l->next;
+column--;
+}
+return l ? l->align : Qt::AlignAuto;
+}
+/*!
+\internal
+*/
+void Q3ListView::show()
+{
+// Reimplemented to setx the correct background mode and viewed
+// area size.
+if (!isVisible()) {
+reconfigureItems();
+updateGeometries();
+}
+Q3ScrollView::show();
+}
+/*!
+Updates the sizes of the viewport, header, scroll bars and so on.
+\warning Don't call this directly; call triggerUpdate() instead.
+*/
+void Q3ListView::updateContents()
+{
+if (d->updateHeader)
+header()->adjustHeaderSize();
+d->updateHeader = false;
+if (!isVisible()) {
+// Not in response to a setText/setPixmap any more.
+return;
+}
+d->drawables.clear();
+viewport()->setUpdatesEnabled(false);
+updateGeometries();
+viewport()->setUpdatesEnabled(true);
+viewport()->repaint();
+}
+void Q3ListView::updateGeometries()
+{
+int th = d->r->totalHeight();
+int tw = d->h->headerWidth();
+if (d->h->offset() &&
+tw < d->h->offset() + d->h->width())
+horizontalScrollBar()->setValue(tw - Q3ListView::d->h->width());
+#if 0
+if (QApplication::reverseLayout() && d->h->offset() != horizontalScrollBar()->value())
+horizontalScrollBar()->setValue(d->h->offset());
+#endif
+verticalScrollBar()->raise();
+resizeContents(tw, th);
+d->drawables.clear();
+if (d->h->isHidden()) {
+setMargins(0, 0, 0, 0);
+} else {
+QSize hs(d->h->sizeHint());
+setMargins(0, hs.height(), 0, 0);
+d->h->setGeometry(viewport()->x(), viewport()->y()-hs.height(),
+visibleWidth(), hs.height());
+}
+}
+/*!
+Updates the display when the section \a section has changed size
+from the old size, \a os, to the new size, \a ns.
+*/
+void Q3ListView::handleSizeChange(int section, int os, int ns)
+{
+bool upe = viewport()->updatesEnabled();
+if (upe)
+viewport()->setUpdatesEnabled(false);
+viewport()->setAttribute(Qt::WA_UpdatesDisabled, true);
+int sx = horizontalScrollBar()->value();
+bool sv = horizontalScrollBar()->isVisible();
+updateGeometries();
+bool fullRepaint = d->fullRepaintOnComlumnChange || sx != horizontalScrollBar()->value()
+|| sv != horizontalScrollBar()->isVisible();
+d->fullRepaintOnComlumnChange = false;
+if (upe)
+viewport()->setUpdatesEnabled(true);
+if (fullRepaint) {
+viewport()->repaint();
+return;
+}
+int actual = d->h->mapToActual(section);
+int dx = ns - os;
+int left = d->h->cellPos(actual) - contentsX() + d->h->cellSize(actual);
+if (dx > 0)
+left -= dx;
+if (left < visibleWidth())
+viewport()->scroll(dx, 0, QRect(left, 0, visibleWidth() - left, visibleHeight()));
+viewport()->repaint(left - 4 - d->ellipsisWidth, 0, 4 + d->ellipsisWidth,
+visibleHeight()); // border between the items and ellipses width
+// map auto to left for now. Need to fix this once we support
+// reverse layout on the listview.
+int align = columnAlignment(section);
+if (align == Qt::AlignAuto) align = Qt::AlignLeft;
+if (align != Qt::AlignAuto && align != Qt::AlignLeft)
+viewport()->repaint(d->h->cellPos(actual) - contentsX(), 0,
+d->h->cellSize(actual), visibleHeight());
+if (currentItem() && currentItem()->renameBox) {
+QRect r = itemRect(currentItem());
+r = QRect(viewportToContents(r.topLeft()), r.size());
+r.setLeft(header()->sectionPos(currentItem()->renameCol));
+r.setWidth(header()->sectionSize(currentItem()->renameCol) - 1);
+if (currentItem()->renameCol == 0)
+r.setLeft(r.left() + itemMargin() + (currentItem()->depth() +
+(rootIsDecorated() ? 1 : 0)) * treeStepSize() - 1);
+if (currentItem()->pixmap(currentItem()->renameCol))
+r.setLeft(r.left() + currentItem()->pixmap(currentItem()->renameCol)->width());
+if (r.x() - contentsX() < 0)
+r.setX(contentsX());
+if (r.width() > visibleWidth())
+r.setWidth(visibleWidth());
+addChild(currentItem()->renameBox, r.x(), r.y());
+currentItem()->renameBox->resize(r.size());
+}
+}
+/*
+Very smart internal slot that repaints \e only the items that need
+to be repainted. Don't use this directly; call repaintItem()
+instead.
+*/
+void Q3ListView::updateDirtyItems()
+{
+if (d->timer->isActive() || d->dirtyItems.isEmpty())
+return;
+QRect ir;
+for (int i = 0; i < d->dirtyItems.size(); ++i) {
+const Q3ListViewItem *item = d->dirtyItems.at(i);
+ir = ir.united(itemRect(item));
+}
+d->dirtyItems.clear();
+if (!ir.isEmpty())  {                      // rectangle to be repainted
+if (ir.x() < 0)
+ir.moveBy(-ir.x(), 0);
+viewport()->repaint(ir);
+}
+}
+void Q3ListView::makeVisible()
+{
+if (d->focusItem)
+ensureItemVisible(d->focusItem);
+}
+/*!
+Ensures that the header is correctly sized and positioned when the
+resize event \a e occurs.
+*/
+void Q3ListView::resizeEvent(QResizeEvent *e)
+{
+Q3ScrollView::resizeEvent(e);
+d->fullRepaintOnComlumnChange = true;
+d->h->resize(visibleWidth(), d->h->height());
+d->h->adjustHeaderSize();
+}
+/*! \reimp */
+void Q3ListView::viewportResizeEvent(QResizeEvent *e)
+{
+Q3ScrollView::viewportResizeEvent(e);
+d->h->resize(visibleWidth(), d->h->height());
+if (resizeMode() != NoColumn && currentItem() && currentItem()->renameBox) {
+QRect r = itemRect(currentItem());
+r = QRect(viewportToContents(r.topLeft()), r.size());
+r.setLeft(header()->sectionPos(currentItem()->renameCol));
+r.setWidth(header()->sectionSize(currentItem()->renameCol) - 1);
+if (currentItem()->renameCol == 0)
+r.setLeft(r.left() + itemMargin() + (currentItem()->depth() +
+(rootIsDecorated() ? 1 : 0)) * treeStepSize() - 1);
+if (currentItem()->pixmap(currentItem()->renameCol))
+r.setLeft(r.left() + currentItem()->pixmap(currentItem()->renameCol)->width());
+if (r.x() - contentsX() < 0)
+r.setX(contentsX());
+if (r.width() > visibleWidth())
+r.setWidth(visibleWidth());
+addChild(currentItem()->renameBox, r.x(), r.y());
+currentItem()->renameBox->resize(r.size());
+}
+}
+/*!
+Triggers a size, geometry and content update during the next
+iteration of the event loop. Ensures that there'll be just one
+update to avoid flicker.
+*/
+void Q3ListView::triggerUpdate()
+{
+if (!isVisible() || !updatesEnabled()) {
+// Not in response to a setText/setPixmap any more.
+return; // it will update when shown, or something.
+}
+d->timer->start(0, true);
+}
+/*!
+Redirects the event \a e relating to object \a o, for the viewport
+to mousePressEvent(), keyPressEvent() and friends.
+*/
+bool Q3ListView::eventFilter(QObject * o, QEvent * e)
+{
+if (o == d->h &&
+e->type() >= QEvent::MouseButtonPress &&
+e->type() <= QEvent::MouseMove) {
+QMouseEvent * me = (QMouseEvent *)e;
+QMouseEvent me2(me->type(),
+QPoint(me->pos().x(),
+me->pos().y() - d->h->height()),
+me->button(), me->state());
+switch(me2.type()) {
+case QEvent::MouseButtonDblClick:
+if (me2.button() == Qt::RightButton)
+return true;
+break;
+case QEvent::MouseMove:
+if (me2.state() & Qt::RightButton) {
+viewportMouseMoveEvent(&me2);
+return true;
+}
+break;
+default:
+break;
+}
+} else if (o == viewport()) {
+QFocusEvent * fe = (QFocusEvent *)e;
+switch(e->type()) {
+case QEvent::FocusIn:
+focusInEvent(fe);
+return true;
+case QEvent::FocusOut:
+focusOutEvent(fe);
+return true;
+#ifndef QT_NO_TOOLTIP
+case QEvent::ToolTip:
+{
+if (!showToolTips())
+return false;
+QHelpEvent *he = static_cast<QHelpEvent *>(e);
+Q3ListViewItem *item = itemAt(he->pos());
+QPoint contentsPos = viewportToContents(he->pos());
+if (!item || !item->columns) {
+QToolTip::showText(he->globalPos(), QString(), viewport());
+return true;
+}
+int col = header()->sectionAt(contentsPos.x());
+Q3ListViewPrivate::ItemColumnInfo *ci = (Q3ListViewPrivate::ItemColumnInfo*)item->columns;
+for (int i = 0; ci && (i < col); ++i)
+ci = ci->next;
+if (!ci || !ci->truncated)
+QToolTip::showText(he->globalPos(), QString(), viewport());
+else
+QToolTip::showText(he->globalPos(), item->text(col), viewport());
+return true;
+}
+#endif
+default:
+// nothing
+break;
+}
+} else if (qobject_cast<QLineEdit*>(o)) {
+if (currentItem() && currentItem()->renameBox) {
+if (e->type() == QEvent::KeyPress) {
+QKeyEvent *ke = (QKeyEvent*)e;
+if (ke->key() == Qt::Key_Return ||
+ke->key() == Qt::Key_Enter) {
+currentItem()->okRename(currentItem()->renameCol);
+return true;
+} else if (ke->key() == Qt::Key_Escape) {
+currentItem()->cancelRename(currentItem()->renameCol);
+return true;
+}
+} else if (e->type() == QEvent::FocusOut) {
+if (((QFocusEvent*)e)->reason() != Qt::PopupFocusReason) {
+QCustomEvent *e = new QCustomEvent(9999);
+QApplication::postEvent(o, e);
+return true;
+}
+} else if (e->type() == 9999) {
+if (d->defRenameAction == Reject)
+currentItem()->cancelRename(currentItem()->renameCol);
+else
+currentItem()->okRename(currentItem()->renameCol);
+return true;
+}
+}
+}
+return Q3ScrollView::eventFilter(o, e);
+}
+/*!
+Returns a pointer to the list view containing this item.
+Note that this function traverses the items to the root to find the
+listview. This function will return 0 for taken items - see
+Q3ListViewItem::takeItem()
+*/
+Q3ListView * Q3ListViewItem::listView() const
+{
+const Q3ListViewItem* c = this;
+while (c && !c->is_root)
+c = c->parentItem;
+if (!c)
+return 0;
+return ((Q3ListViewPrivate::Root*)c)->theListView();
+}
+/*!
+Returns the depth of this item.
+*/
+int Q3ListViewItem::depth() const
+{
+return parentItem ? parentItem->depth()+1 : -1; // -1 == the hidden root
+}
+/*!
+Returns a pointer to the item immediately above this item on the
+screen. This is usually the item's closest older sibling, but it
+may also be its parent or its next older sibling's youngest child,
+or something else if anyoftheabove->height() returns 0. Returns 0
+if there is no item immediately above this item.
+This function assumes that all parents of this item are open (i.e.
+that this item is visible, or can be made visible by scrolling).
+This function might be relatively slow because of the tree
+traversions needed to find the correct item.
+\sa itemBelow() Q3ListView::itemRect()
+*/
+Q3ListViewItem * Q3ListViewItem::itemAbove() const
+{
+if (!parentItem)
+return 0;
+Q3ListViewItem * c = parentItem;
+if (c->childItem != this) {
+c = c->childItem;
+while(c && c->siblingItem != this)
+c = c->siblingItem;
+if (!c)
+return 0;
+while(c->isOpen() && c->childItem) {
+c = c->childItem;
+while(c->siblingItem)
+c = c->siblingItem;                // assign c's sibling to c
+}
+}
+if (c && (!c->height() || !c->isEnabled()))
+return c->itemAbove();
+return c;
+}
+/*!
+Returns a pointer to the item immediately below this item on the
+screen. This is usually the item's eldest child, but it may also
+be its next younger sibling, its parent's next younger sibling,
+grandparent's, etc., or something else if anyoftheabove->height()
+returns 0. Returns 0 if there is no item immediately below this
+item.
+This function assumes that all parents of this item are open (i.e.
+that this item is visible or can be made visible by scrolling).
+\sa itemAbove() Q3ListView::itemRect()
+*/
+Q3ListViewItem * Q3ListViewItem::itemBelow() const
+{
+Q3ListViewItem * c = 0;
+if (isOpen() && childItem) {
+c = childItem;
+} else if (siblingItem) {
+c = siblingItem;
+} else if (parentItem) {
+c = const_cast<Q3ListViewItem*>(this);
+do {
+c = c->parentItem;
+} while(c->parentItem && !c->siblingItem);
+if (c)
+c = c->siblingItem;
+}
+if (c && (!c->height() || !c->isEnabled()))
+return c->itemBelow();
+return c;
+}
+/*!
+\fn bool Q3ListViewItem::isOpen() const
+Returns true if this list view item has children \e and they are
+not explicitly hidden; otherwise returns false.
+\sa setOpen()
+*/
+/*!
+Returns the first (top) child of this item, or 0 if this item has
+no children.
+Note that the children are not guaranteed to be sorted properly.
+Q3ListView and Q3ListViewItem try to postpone or avoid sorting to
+the greatest degree possible, in order to keep the user interface
+snappy.
+\sa nextSibling() sortChildItems()
+*/
+Q3ListViewItem* Q3ListViewItem::firstChild() const
+{
+enforceSortOrder();
+return childItem;
+}
+/*!
+Returns the parent of this item, or 0 if this item has no parent.
+\sa firstChild(), nextSibling()
+*/
+Q3ListViewItem* Q3ListViewItem::parent() const
+{
+if (!parentItem || parentItem->is_root) return 0;
+return parentItem;
+}
+/*!
+\fn Q3ListViewItem* Q3ListViewItem::nextSibling() const
+Returns the sibling item below this item, or 0 if there is no
+sibling item after this item.
+Note that the siblings are not guaranteed to be sorted properly.
+Q3ListView and Q3ListViewItem try to postpone or avoid sorting to
+the greatest degree possible, in order to keep the user interface
+snappy.
+\sa firstChild() sortChildItems()
+*/
+/*!
+\fn int Q3ListViewItem::childCount () const
+Returns how many children this item has. The count only includes
+the item's immediate children.
+*/
+/*!
+Returns the height of this item in pixels. This does not include
+the height of any children; totalHeight() returns that.
+*/
+int Q3ListViewItem::height() const
+{
+Q3ListViewItem * that = (Q3ListViewItem *)this;
+if (!that->configured) {
+that->configured = true;
+that->setup(); // ### virtual non-const function called in const
+}
+return visible ? ownHeight : 0;
+}
+/*!
+Call this function when the value of width() may have changed for
+column \a c. Normally, you should call this if text(c) changes.
+Passing -1 for \a c indicates that all columns may have changed.
+It is more efficient to pass -1 if two or more columns have
+changed than to call widthChanged() separately for each one.
+\sa width()
+*/
+void Q3ListViewItem::widthChanged(int c) const
+{
+Q3ListView *lv = listView();
+if (lv)
+lv->widthChanged(this, c);
+}
+/*!
+\fn void  Q3ListView::dropped (QDropEvent * e)
+This signal is emitted, when a drop event occurred on the
+viewport (not onto an item).
+\a e provides all the information about the drop.
+*/
+/*!
+\fn void Q3ListView::selectionChanged()
+This signal is emitted whenever the set of selected items has
+changed (normally before the screen update). It is available both
+in \c Single selection and \c Multi selection mode but is most
+useful in \c Multi selection mode.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+\sa setSelected() Q3ListViewItem::setSelected()
+*/
+/*!
+\fn void Q3ListView::pressed(Q3ListViewItem *item)
+This signal is emitted whenever the user presses the mouse button
+in a list view. \a item is the list view item on which the user
+pressed the mouse button, or 0 if the user didn't press the mouse
+on an item.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+*/
+/*!
+\fn void Q3ListView::pressed(Q3ListViewItem *item, const QPoint &pnt, int c)
+\overload
+This signal is emitted whenever the user presses the mouse button
+in a list view. \a item is the list view item on which the user
+pressed the mouse button, or 0 if the user didn't press the mouse
+on an item. \a pnt is the position of the mouse cursor in global
+coordinates, and \a c is the column where the mouse cursor was
+when the user pressed the mouse button.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+*/
+/*!
+\fn void Q3ListView::clicked(Q3ListViewItem *item)
+This signal is emitted whenever the user clicks (mouse pressed \e
+and mouse released) in the list view. \a item is the clicked list
+view item, or 0 if the user didn't click on an item.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+*/
+/*!
+\fn void Q3ListView::mouseButtonClicked(int button, Q3ListViewItem * item, const QPoint & pos, int c)
+This signal is emitted whenever the user clicks (mouse pressed \e
+and mouse released) in the list view at position \a pos. \a button
+is the mouse button that the user pressed, \a item is the clicked
+list view item or 0 if the user didn't click on an item. If \a
+item is not 0, \a c is the list view column into which the user
+pressed; if \a item is 0 \a{c}'s value is undefined.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+*/
+/*!
+\fn void Q3ListView::mouseButtonPressed(int button, Q3ListViewItem * item, const QPoint & pos, int c)
+This signal is emitted whenever the user pressed the mouse button
+in the list view at position \a pos. \a button is the mouse button
+which the user pressed, \a item is the pressed list view item or 0
+if the user didn't press on an item. If \a item is not 0, \a c is
+the list view column into which the user pressed; if \a item is 0
+\a{c}'s value is undefined.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+*/
+/*!
+\fn void Q3ListView::clicked(Q3ListViewItem *item, const QPoint &pnt, int c)
+\overload
+This signal is emitted whenever the user clicks (mouse pressed \e
+and mouse released) in the list view. \a item is the clicked list
+view item, or 0 if the user didn't click on an item. \a pnt is the
+position where the user has clicked in global coordinates. If \a
+item is not 0, \a c is the list view column into which the user
+pressed; if \a item is 0 \a{c}'s value is undefined.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+*/
+/*!
+\fn void Q3ListView::selectionChanged(Q3ListViewItem *item)
+\overload
+This signal is emitted whenever the selected item has changed in
+\c Single selection mode (normally after the screen update). The
+argument is the newly selected \a item.
+In \c Multi selection mode, use the no argument overload of this
+signal.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+\sa setSelected() Q3ListViewItem::setSelected() currentChanged()
+*/
+/*!
+\fn void Q3ListView::currentChanged(Q3ListViewItem *item)
+This signal is emitted whenever the current item has changed
+(normally after the screen update). The current item is the item
+responsible for indicating keyboard focus.
+The argument is the newly current \a item, or 0 if the change made
+no item current. This can happen, for example, if all the items in
+the list view are deleted.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+\sa setCurrentItem() currentItem()
+*/
+/*!
+\fn void Q3ListView::expanded(Q3ListViewItem *item)
+This signal is emitted when \a item has been expanded, i.e. when
+the children of \a item are shown.
+\sa setOpen() collapsed()
+*/
+/*!
+\fn void Q3ListView::collapsed(Q3ListViewItem *item)
+This signal is emitted when the \a item has been collapsed, i.e.
+when the children of \a item are hidden.
+\sa setOpen() expanded()
+*/
+/*!
+Processes the mouse press event \a e on behalf of the viewed widget.
+*/
+void Q3ListView::contentsMousePressEvent(QMouseEvent * e)
+{
+contentsMousePressEventEx(e);
+}
+void Q3ListView::contentsMousePressEventEx(QMouseEvent * e)
+{
+if (!e)
+return;
+if (!d->ignoreEditAfterFocus)
+d->startEdit = true;
+d->ignoreEditAfterFocus = false;
+if (currentItem() && currentItem()->renameBox &&
+!itemRect(currentItem()).contains(e->pos())) {
+d->startEdit = false;
+if (d->defRenameAction == Reject)
+currentItem()->cancelRename(currentItem()->renameCol);
+else
+currentItem()->okRename(currentItem()->renameCol);
+}
+d->startDragItem = 0;
+d->dragStartPos = e->pos();
+QPoint vp = contentsToViewport(e->pos());
+d->ignoreDoubleClick = false;
+d->buttonDown = true;
+Q3ListViewItem * i = itemAt(vp);
+d->pressedEmptyArea = e->y() > contentsHeight();
+if (i && !i->isEnabled())
+return;
+if (d->startEdit && (i != currentItem() || (i && !i->isSelected())))
+d->startEdit = false;
+Q3ListViewItem *oldCurrent = currentItem();
+if (e->button() == Qt::RightButton && (e->state() & Qt::ControlButton))
+goto emit_signals;
+if (!i) {
+if (!(e->state() & Qt::ControlButton))
+clearSelection();
+goto emit_signals;
+} else {
+// No new anchor when using shift
+if (!(e->state() & Qt::ShiftButton))
+d->selectAnchor = i;
+}
+if ((i->isExpandable() || i->childCount()) &&
+d->h->mapToLogical(d->h->cellAt(vp.x())) == 0) {
+int x1 = vp.x() +
+d->h->offset() -
+d->h->cellPos(d->h->mapToActual(0));
+int draw = 0;
+for (; draw < d->drawables.size(); ++draw)
+if (d->drawables.at(draw).i == i)
+break;
+if (draw < d->drawables.size()) {
+Q3ListViewPrivate::DrawableItem it = d->drawables.at(draw);
+QStyleOptionQ3ListView opt = getStyleOption(this, i);
+x1 -= treeStepSize() * (it.l - 1);
+QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_Q3ListView, &opt,
+QPoint(x1, e->pos().y()), this);
+if (ctrl == QStyle::SC_Q3ListViewExpand &&
+e->type() == style()->styleHint(QStyle::SH_Q3ListViewExpand_SelectMouseType, 0,
+this)) {
+d->buttonDown = false;
+if (e->button() == Qt::LeftButton) {
+bool close = i->isOpen();
+setOpen(i, !close);
+// ### Looks dangerous, removed because of reentrance problems
+// qApp->processEvents();
+if (!d->focusItem) {
+d->focusItem = i;
+repaintItem(d->focusItem);
+emit currentChanged(d->focusItem);
+}
+if (close) {
+bool newCurrent = false;
+Q3ListViewItem *ci = d->focusItem;
+while (ci) {
+if (ci->parent() && ci->parent() == i) {
+newCurrent = true;
+break;
+}
+ci = ci->parent();
+}
+if (newCurrent) {
+setCurrentItem(i);
+}
+}
+}
+d->ignoreDoubleClick = true;
+d->buttonDown = false;
+goto emit_signals;
+}
+}
+}
+d->select = d->selectionMode == Multi ? !i->isSelected() : true;
+{// calculate activatedP
+activatedByClick = true;
+QPoint topLeft = itemRect(i).topLeft(); //### inefficient?
+activatedP = vp - topLeft;
+int xdepth = treeStepSize() * (i->depth() + (rootIsDecorated() ? 1 : 0))
++ itemMargin();
+xdepth += d->h->sectionPos(d->h->mapToSection(0));
+activatedP.rx() -= xdepth;
+}
+i->activate();
+activatedByClick = false;
+if (i != d->focusItem)
+setCurrentItem(i);
+else
+repaintItem(i);
+d->pressedSelected = i && i->isSelected();
+if (i->isSelectable() && selectionMode() != NoSelection) {
+if (selectionMode() == Single)
+setSelected(i, true);
+else if (selectionMode() == Multi)
+setSelected(i, d->select);
+else if (selectionMode() == Extended) {
+bool changed = false;
+if (!(e->state() & (Qt::ControlButton | Qt::ShiftButton))) {
+if (!i->isSelected()) {
+bool blocked = signalsBlocked();
+blockSignals(true);
+clearSelection();
+blockSignals(blocked);
+i->setSelected(true);
+changed = true;
+}
+} else {
+if (e->state() & Qt::ShiftButton)
+d->pressedSelected = false;
+if ((e->state() & Qt::ControlButton) && !(e->state() & Qt::ShiftButton) && i) {
+i->setSelected(!i->isSelected());
+changed = true;
+d->pressedSelected = false;
+} else if (!oldCurrent || !i || oldCurrent == i) {
+if ((bool)i->selected != d->select) {
+changed = true;
+i->setSelected(d->select);
+}
+// Shift pressed in Extended mode ---
+} else {
+changed = selectRange(i, oldCurrent, d->selectAnchor);
+}
+}
+if (changed) {
+triggerUpdate();
+emit selectionChanged();
+#ifndef QT_NO_ACCESSIBILITY
+QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection);
+#endif
+}
+}
+}
+emit_signals:
+if (i && !d->buttonDown &&
+vp.x() + contentsX() < itemMargin() + (i->depth() + (rootIsDecorated() ? 1 : 0)) * treeStepSize())
+i = 0;
+d->pressedItem = i;
+int c = i ? d->h->mapToLogical(d->h->cellAt(vp.x())) : -1;
+if (!i || (i && i->isEnabled())) {
+emit pressed(i);
+emit pressed(i, viewport()->mapToGlobal(vp), c);
+}
+emit mouseButtonPressed(e->button(), i, viewport()->mapToGlobal(vp), c);
+if (e->button() == Qt::RightButton && i == d->pressedItem) {
+if (!i && !(e->state() & Qt::ControlButton))
+clearSelection();
+emit rightButtonPressed(i, viewport()->mapToGlobal(vp), c);
+}
+}
+/*!
+\reimp
+*/
+void Q3ListView::contentsContextMenuEvent(QContextMenuEvent *e)
+{
+if (!receivers(SIGNAL(contextMenuRequested(Q3ListViewItem*,QPoint,int)))) {
+e->ignore();
+return;
+}
+if (e->reason() == QContextMenuEvent::Keyboard) {
+Q3ListViewItem *item = currentItem();
+if (item) {
+QRect r = itemRect(item);
+QPoint p = r.topLeft();
+if (allColumnsShowFocus())
+p += QPoint(width() / 2, (r.height() / 2));
+else
+p += QPoint(columnWidth(0) / 2, (r.height() / 2));
+p.rx() = qMax(0, p.x());
+p.rx() = qMin(visibleWidth(), p.x());
+emit contextMenuRequested(item, viewport()->mapToGlobal(p), -1);
+}
+} else {
+QPoint vp = contentsToViewport(e->pos());
+Q3ListViewItem * i = itemAt(vp);
+int c = i ? d->h->mapToLogical(d->h->cellAt(vp.x())) : -1;
+emit contextMenuRequested(i, viewport()->mapToGlobal(vp), c);
+}
+}
+/*!
+Processes the mouse release event \a e on behalf of the viewed widget.
+*/
+void Q3ListView::contentsMouseReleaseEvent(QMouseEvent * e)
+{
+contentsMouseReleaseEventEx(e);
+}
+void Q3ListView::contentsMouseReleaseEventEx(QMouseEvent * e)
+{
+d->startDragItem = 0;
+bool emitClicked = !d->pressedItem || d->buttonDown;
+d->buttonDown = false;
+// delete and disconnect autoscroll timer, if we have one
+if (d->scrollTimer) {
+disconnect(d->scrollTimer, SIGNAL(timeout()),
+this, SLOT(doAutoScroll()));
+d->scrollTimer->stop();
+delete d->scrollTimer;
+d->scrollTimer = 0;
+}
+if (!e)
+return;
+if (d->selectionMode == Extended &&
+d->focusItem == d->pressedItem &&
+d->pressedSelected && d->focusItem &&
+e->button() == Qt::LeftButton) {
+bool block = signalsBlocked();
+blockSignals(true);
+clearSelection();
+blockSignals(block);
+d->focusItem->setSelected(true);
+emit selectionChanged();
+#ifndef QT_NO_ACCESSIBILITY
+QAccessible::updateAccessibility(viewport(), 0, QAccessible::Selection);
+#endif
+}
+QPoint vp = contentsToViewport(e->pos());
+Q3ListViewItem *i = itemAt(vp);
+if (i && !i->isEnabled())
+return;
+if (i && i == d->pressedItem && (i->isExpandable() || i->childCount()) &&
+!d->h->mapToLogical(d->h->cellAt(vp.x())) && e->button() == Qt::LeftButton &&
+e->type() == style()->styleHint(QStyle::SH_Q3ListViewExpand_SelectMouseType, 0, this)) {
+int draw = 0;
+for (; draw < d->drawables.size(); ++draw)
+if (d->drawables.at(draw).i == i)
+break;
+if (draw < d->drawables.size()) {
+int x1 = vp.x() + d->h->offset() - d->h->cellPos(d->h->mapToActual(0)) -
+(treeStepSize() * (d->drawables.at(draw).l - 1));
+QStyleOptionQ3ListView opt = getStyleOption(this, i);
+QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_Q3ListView, &opt,
+QPoint(x1, e->pos().y()), this);
+if (ctrl == QStyle::SC_Q3ListViewExpand) {
+bool close = i->isOpen();
+setOpen(i, !close);
+// ### Looks dangerous, removed because of reentrance problems
+// qApp->processEvents();
+if (!d->focusItem) {
+d->focusItem = i;
+repaintItem(d->focusItem);
+emit currentChanged(d->focusItem);
+}
+if (close) {
+bool newCurrent = false;
+Q3ListViewItem *ci = d->focusItem;
+while (ci) {
+if (ci->parent() && ci->parent() == i) {
+newCurrent = true;
+break;
+}
+ci = ci->parent();
+}
+if (newCurrent)
+setCurrentItem(i);
+d->ignoreDoubleClick = true;
+}
+}
+}
+}
+if (i == d->pressedItem && i && i->isSelected() && e->button() == Qt::LeftButton && d->startEdit) {
+QRect r = itemRect(currentItem());
+r = QRect(viewportToContents(r.topLeft()), r.size());
+d->pressedColumn = header()->sectionAt( e->pos().x());
+r.setLeft(header()->sectionPos(d->pressedColumn));
+r.setWidth(header()->sectionSize(d->pressedColumn) - 1);
+if (d->pressedColumn == 0)
+r.setLeft(r.left() + itemMargin() + (currentItem()->depth() +
+(rootIsDecorated() ? 1 : 0)) * treeStepSize() - 1);
+if (r.contains(e->pos()) &&
+!(e->state() & (Qt::ShiftButton | Qt::ControlButton)))
+d->renameTimer->start(QApplication::doubleClickInterval(), true);
+}
+if (i && vp.x() + contentsX() < itemMargin() + (i->depth() + (rootIsDecorated() ? 1 : 0)) * treeStepSize())
+i = 0;
+emitClicked = emitClicked && d->pressedItem == i;
+d->pressedItem = 0;
+if (emitClicked) {
+if (!i || (i && i->isEnabled())) {
+emit clicked(i);
+emit clicked(i, viewport()->mapToGlobal(vp), d->h->mapToLogical(d->h->cellAt(vp.x())));
+}
+emit mouseButtonClicked(e->button(), i, viewport()->mapToGlobal(vp),
+i ? d->h->mapToLogical(d->h->cellAt(vp.x())) : -1);
+if (e->button() == Qt::RightButton) {
+if (!i) {
+if (!(e->state() & Qt::ControlButton))
+clearSelection();
+emit rightButtonClicked(0, viewport()->mapToGlobal(vp), -1);
+return;
+}
+int c = d->h->mapToLogical(d->h->cellAt(vp.x()));
+emit rightButtonClicked(i, viewport()->mapToGlobal(vp), c);
+}
+}
+}
+/*!
+Processes the mouse double-click event \a e on behalf of the viewed widget.
+*/
+void Q3ListView::contentsMouseDoubleClickEvent(QMouseEvent * e)
+{
+d->renameTimer->stop();
+d->startEdit = false;
+if (!e || e->button() != Qt::LeftButton)
+return;
+// ensure that the following mouse moves and eventual release is
+// ignored.
+d->buttonDown = false;
+if (d->ignoreDoubleClick) {
+d->ignoreDoubleClick = false;
+return;
+}
+QPoint vp = contentsToViewport(e->pos());
+Q3ListViewItem * i = itemAt(vp);
+// we emit doubleClicked when the item is null (or enabled) to be consistent with
+// rightButtonClicked etc.
+if (!i || i->isEnabled()) {
+int c = d->h->mapToLogical(d->h->cellAt(vp.x()));
+emit doubleClicked(i, viewport()->mapToGlobal(vp), c);
+}
+if (!i || !i->isEnabled())
+return;
+if (!i->isOpen()) {
+if (i->isExpandable() || i->childCount())
+setOpen(i, true);
+} else {
+setOpen(i, false);
+}
+// we emit the 'old' obsolete doubleClicked only if the item is not null and enabled
+emit doubleClicked(i);
+}
+/*!
+Processes the mouse move event \a e on behalf of the viewed widget.
+*/
+void Q3ListView::contentsMouseMoveEvent(QMouseEvent * e)
+{
+if (!e)
+return;
+bool needAutoScroll = false;
+QPoint vp = contentsToViewport(e->pos());
+Q3ListViewItem * i = itemAt(vp);
+if (i && !i->isEnabled())
+return;
+if (i != d->highlighted &&
+!(d->pressedItem &&
+(d->pressedItem->isSelected() || d->selectionMode == NoSelection) &&
+d->pressedItem->dragEnabled())) {
+if (i) {
+emit onItem(i);
+} else {
+emit onViewport();
+}
+d->highlighted = i;
+}
+if (d->startDragItem)
+i = d->startDragItem;
+if (!d->buttonDown ||
+((e->state() & Qt::LeftButton) != Qt::LeftButton &&
+(e->state() & Qt::MidButton) != Qt::MidButton &&
+(e->state() & Qt::RightButton) != Qt::RightButton))
+return;
+if (d->pressedItem &&
+(d->pressedItem->isSelected() || d->selectionMode == NoSelection) &&
+d->pressedItem->dragEnabled()) {
+if (!d->startDragItem) {
+setSelected(d->pressedItem, true);
+d->startDragItem = d->pressedItem;
+}
+if ((d->dragStartPos - e->pos()).manhattanLength() > QApplication::startDragDistance()) {
+d->buttonDown = false;
+#ifndef QT_NO_DRAGANDDROP
+startDrag();
+#endif
+}
+return;
+}
+// check, if we need to scroll
+if (vp.y() > visibleHeight() || vp.y() < 0)
+needAutoScroll = true;
+// if we need to scroll and no autoscroll timer is started,
+// connect the timer
+if (needAutoScroll && !d->scrollTimer) {
+d->scrollTimer = new QTimer(this);
+connect(d->scrollTimer, SIGNAL(timeout()),
+this, SLOT(doAutoScroll()));
+d->scrollTimer->start(100, false);
+// call it once manually
+doAutoScroll(vp);
+}
+// if we don't need to autoscroll
+if (!needAutoScroll) {
+// if there is a autoscroll timer, delete it
+if (d->scrollTimer) {
+disconnect(d->scrollTimer, SIGNAL(timeout()),
+this, SLOT(doAutoScroll()));
+d->scrollTimer->stop();
+delete d->scrollTimer;
+d->scrollTimer = 0;
+}
+// call this to select an item (using the pos from the event)
+doAutoScroll(vp);
+}
+}
+/*!
+This slot handles auto-scrolling when the mouse button is pressed
+and the mouse is outside the widget.
+*/
+void Q3ListView::doAutoScroll()
+{
+doAutoScroll(QPoint());
+}
+/*
+Handles auto-scrolling when the mouse button is pressed
+and the mouse is outside the widget.
+If cursorPos is (0,0) (isNull == true) it uses the current QCursor::pos, otherwise it uses cursorPos
+*/
+void Q3ListView::doAutoScroll(const QPoint &cursorPos)
+{
+QPoint pos = cursorPos.isNull() ? viewport()->mapFromGlobal(QCursor::pos()) :  cursorPos;
+if (!d->focusItem || (d->pressedEmptyArea && pos.y() > contentsHeight()))
+return;
+bool down = pos.y() > itemRect(d->focusItem).y();
+int g = pos.y() + contentsY();
+if (down && pos.y() > height() )
+g = height() + contentsY();
+else if (pos.y() < 0)
+g = contentsY();
+Q3ListViewItem *c = d->focusItem, *old = 0;
+Q3ListViewItem *oldCurrent = c;
+if (down) {
+int y = itemRect(d->focusItem).y() + contentsY();
+while(c && y + c->height() <= g) {
+y += c->height();
+old = c;
+c = c->itemBelow();
+}
+if (!c && old)
+c = old;
+} else {
+int y = itemRect(d->focusItem).y() + contentsY();
+while(c && y >= g) {
+old = c;
+c = c->itemAbove();
+if (c)
+y -= c->height();
+}
+if (!c && old)
+c = old;
+}
+if (!c || c == d->focusItem)
+return;
+if (d->focusItem) {
+if (d->selectionMode == Multi) {
+// also (de)select the ones in between
+Q3ListViewItem * b = d->focusItem;
+bool down = (itemPos(c) > itemPos(b));
+while(b && b != c) {
+if (b->isSelectable())
+setSelected(b, d->select);
+b = down ? b->itemBelow() : b->itemAbove();
+}
+if (c->isSelectable())
+setSelected(c, d->select);
+} else if (d->selectionMode == Extended) {
+if (selectRange(c, oldCurrent, d->selectAnchor)) {
+triggerUpdate();
+emit selectionChanged();
+}
+}
+}
+setCurrentItem(c);
+d->visibleTimer->start(1, true);
+}
+/*!
+\reimp
+*/
+void Q3ListView::focusInEvent(QFocusEvent *e)
+{
+d->inMenuMode = false;
+if (d->focusItem) {
+repaintItem(d->focusItem);
+} else if (firstChild() && e->reason() != Qt::MouseFocusReason) {
+d->focusItem = firstChild();
+emit currentChanged(d->focusItem);
+repaintItem(d->focusItem);
+}
+if (e->reason() == Qt::MouseFocusReason) {
+d->ignoreEditAfterFocus = true;
+d->startEdit = false;
+}
+if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) {
+viewport()->repaint();
+}
+}
+/*!
+\reimp
+*/
+QVariant Q3ListView::inputMethodQuery(Qt::InputMethodQuery query) const
+{
+if (query == Qt::ImMicroFocus) {
+QRect mfrect = itemRect(d->focusItem);
+if (mfrect.isValid() && header() && header()->isVisible())
+mfrect.moveBy(0, header()->height());
+return mfrect;
+}
+return QWidget::inputMethodQuery(query);
+}
+/*!
+\reimp
+*/
+void Q3ListView::focusOutEvent(QFocusEvent *e)
+{
+if (e->reason() == Qt::PopupFocusReason && d->buttonDown)
+d->buttonDown = false;
+if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) {
+d->inMenuMode =
+e->reason() == Qt::PopupFocusReason
+|| (qApp->focusWidget() && qApp->focusWidget()->inherits("QMenuBar"));
+if (!d->inMenuMode) {
+viewport()->repaint();
+}
+}
+if (d->focusItem)
+repaintItem(d->focusItem);
+}
+/*!
+\reimp
+*/
+void Q3ListView::keyPressEvent(QKeyEvent * e)
+{
+if (currentItem() && currentItem()->renameBox)
+return;
+if (!firstChild()) {
+e->ignore();
+return; // subclass bug
+}
+Q3ListViewItem* oldCurrent = currentItem();
+if (!oldCurrent) {
+setCurrentItem(firstChild());
+if (d->selectionMode == Single)
+setSelected(firstChild(), true);
+return;
+}
+Q3ListViewItem * i = currentItem();
+Q3ListViewItem *old = i;
+QRect r(itemRect(i));
+Q3ListViewItem * i2;
+bool singleStep = false;
+bool selectCurrent = true;
+bool wasNavigation = true;
+switch(e->key()) {
+case Qt::Key_Backspace:
+case Qt::Key_Delete:
+d->currentPrefix.truncate(0);
+break;
+case Qt::Key_Enter:
+case Qt::Key_Return:
+d->currentPrefix.truncate(0);
+if (i && !i->isSelectable() && i->isEnabled() &&
+(i->childCount() || i->isExpandable() || i->isOpen())) {
+i->setOpen(!i->isOpen());
+return;
+}
+e->ignore();
+if (currentItem() && !currentItem()->isEnabled())
+break;
+emit returnPressed(currentItem());
+// do NOT accept.  QDialog.
+return;
+case Qt::Key_Down:
+selectCurrent = false;
+i = i->itemBelow();
+d->currentPrefix.truncate(0);
+singleStep = true;
+break;
+case Qt::Key_Up:
+selectCurrent = false;
+i = i->itemAbove();
+d->currentPrefix.truncate(0);
+singleStep = true;
+break;
+case Qt::Key_Home:
+selectCurrent = false;
+i = firstChild();
+if (!i->height() || !i->isEnabled())
+i = i->itemBelow();
+d->currentPrefix.truncate(0);
+break;
+case Qt::Key_End:
+selectCurrent = false;
+i = firstChild();
+while (i->nextSibling() && i->nextSibling()->height() && i->nextSibling()->isEnabled())
+i = i->nextSibling();
+while (i->itemBelow())
+i = i->itemBelow();
+d->currentPrefix.truncate(0);
+break;
+case Qt::Key_Next:
+selectCurrent = false;
+i2 = itemAt(QPoint(0, visibleHeight()-1));
+if (i2 == i || !r.isValid() ||
+visibleHeight() <= itemRect(i).bottom()) {
+if (i2)
+i = i2;
+int left = visibleHeight();
+while((i2 = i->itemBelow()) != 0 && left > i2->height()) {
+left -= i2->height();
+i = i2;
+}
+} else {
+if (!i2) {
+// list is shorter than the view, goto last item
+while((i2 = i->itemBelow()) != 0)
+i = i2;
+} else {
+i = i2;
+}
+}
+d->currentPrefix.truncate(0);
+break;
+case Qt::Key_Prior:
+selectCurrent = false;
+i2 = itemAt(QPoint(0, 0));
+if (i == i2 || !r.isValid() || r.top() <= 0) {
+if (i2)
+i = i2;
+int left = visibleHeight();
+while((i2 = i->itemAbove()) != 0 && left > i2->height()) {
+left -= i2->height();
+i = i2;
+}
+} else {
+i = i2;
+}
+d->currentPrefix.truncate(0);
+break;
+case Qt::Key_Plus:
+d->currentPrefix.truncate(0);
+if ( !i->isOpen() && (i->isExpandable() || i->childCount()))
+setOpen(i, true);
+else
+return;
+break;
+case Qt::Key_Right:
+d->currentPrefix.truncate(0);
+if (i->isOpen() && i->childItem) {
+i = i->childItem;
+} else if (!i->isOpen() && (i->isExpandable() || i->childCount())) {
+setOpen(i, true);
+} else if (contentsX() + visibleWidth() < contentsWidth()) {
+horizontalScrollBar()->triggerAction(QScrollBar::SliderSingleStepAdd);
+return;
+} else {
+return;
+}
+break;
+case Qt::Key_Minus:
+d->currentPrefix.truncate(0);
+if (i->isOpen())
+setOpen(i, false);
+else
+return;
+break;
+case Qt::Key_Left:
+d->currentPrefix.truncate(0);
+if (i->isOpen()) {
+setOpen(i, false);
+} else if (i->parentItem && i->parentItem != d->r) {
+i = i->parentItem;
+} else if (contentsX()) {
+horizontalScrollBar()->triggerAction(QScrollBar::SliderSingleStepSub);
+return;
+} else {
+return;
+}
+break;
+case Qt::Key_Space:
+activatedByClick = false;
+d->currentPrefix.truncate(0);
+if (currentItem() && !currentItem()->isEnabled())
+break;
+i->activate();
+if (i->isSelectable() && (d->selectionMode == Multi || d->selectionMode == Extended)) {
+setSelected(i, !i->isSelected());
+d->currentPrefix.truncate(0);
+}
+emit spacePressed(currentItem());
+break;
+case Qt::Key_Escape:
+e->ignore(); // For QDialog
+return;
+case Qt::Key_F2:
+if (currentItem() && currentItem()->renameEnabled(0))
+currentItem()->startRename(0);
+default:
+if (e->text().length() > 0 && e->text()[0].isPrint()) {
+selectCurrent = false;
+wasNavigation = false;
+QString input(d->currentPrefix);
+Q3ListViewItem * keyItem = i;
+QTime now(QTime::currentTime());
+bool tryFirst = true;
+while(keyItem) {
+// try twice, first with the previous string and this char
+if (d->currentPrefixTime.msecsTo(now) <= 400)
+input = input + e->text().toLower();
+else
+input = e->text().toLower();
+if (input.length() == e->text().length()) {
+if (keyItem->itemBelow()) {
+keyItem = keyItem->itemBelow();
+tryFirst = true;
+} else {
+keyItem = firstChild();
+tryFirst = false;
+}
+}
+QString keyItemKey;
+QString prefix;
+while(keyItem) {
+keyItemKey = QString::null;
+// Look first in the sort column, then left to right
+		    if (d->sortcolumn != Unsorted)
+			keyItemKey = keyItem->text(d->sortcolumn);
+for (int col = 0; col < d->h->count() && keyItemKey.isNull(); ++col)
+keyItemKey = keyItem->text(d->h->mapToSection(col));
+if (!keyItemKey.isEmpty()) {
+prefix = keyItemKey;
+prefix.truncate(input.length());
+prefix = prefix.toLower();
+if (prefix == input) {
+d->currentPrefix = input;
+d->currentPrefixTime = now;
+i = keyItem;
+// nonoptimal double-break...
+keyItem = 0;
+input.truncate(0);
+tryFirst = false;
+}
+}
+if (keyItem)
+keyItem = keyItem->itemBelow();
+if (!keyItem && tryFirst) {
+keyItem = firstChild();
+tryFirst = false;
+}
+}
+// then, if appropriate, with just this character
+if (input.length() > e->text().length()) {
+input.truncate(0);
+keyItem = i;
+}
+}
+} else {
+d->currentPrefix.truncate(0);
+if (e->state() & Qt::ControlButton) {
+d->currentPrefix.clear();
+switch (e->key()) {
+case Qt::Key_A:
+selectAll(true);
+break;
+}
+}
+e->ignore();
+return;
+}
+}
+if (!i)
+return;
+if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor)
+d->selectAnchor = i;
+setCurrentItem(i);
+if (i->isSelectable())
+handleItemChange(old, wasNavigation && (e->state() & Qt::ShiftButton),
+wasNavigation && (e->state() & Qt::ControlButton));
+if (d->focusItem && !d->focusItem->isSelected() && d->selectionMode == Single && selectCurrent)
+setSelected(d->focusItem, true);
+if (singleStep)
+d->visibleTimer->start(1, true);
+else
+ensureItemVisible(i);
+}
+/*!
+Returns the list view item at \a viewPos. Note that \a viewPos is
+in the viewport()'s coordinate system, not in the list view's own,
+much larger, coordinate system.
+itemAt() returns 0 if there is no such item.
+Note that you also get the pointer to the item if \a viewPos
+points to the root decoration (see setRootIsDecorated()) of the
+item. To check whether or not \a viewPos is on the root decoration
+of the item, you can do something like this:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 4
+This might be interesting if you use this function to find out
+where the user clicked and if you want to start a drag (which you
+do not want to do if the user clicked onto the root decoration of
+an item).
+\sa itemPos() itemRect() viewportToContents()
+*/
+Q3ListViewItem * Q3ListView::itemAt(const QPoint & viewPos) const
+{
+if (viewPos.x() > contentsWidth() - contentsX())
+return 0;
+if (d->drawables.isEmpty())
+buildDrawableList();
+int g = viewPos.y() + contentsY();
+for (int i = 0; i < d->drawables.size(); ++i) {
+Q3ListViewPrivate::DrawableItem c = d->drawables.at(i);
+if (c.y + c.i->height() > g
+&& c.i->isVisible() && (!c.i->parent() || c.i->parent()->isVisible()))
+return c.y <= g ? c.i : 0;
+}
+return 0;
+}
+/*!
+Returns the y-coordinate of \a item in the list view's coordinate
+system. This function is normally much slower than itemAt() but it
+works for all items, whereas itemAt() normally works only for
+items on the screen.
+This is a thin wrapper around Q3ListViewItem::itemPos().
+\sa itemAt() itemRect()
+*/
+int Q3ListView::itemPos(const Q3ListViewItem * item)
+{
+return item ? item->itemPos() : 0;
+}
+/*!
+\property Q3ListView::multiSelection
+\brief whether the list view is in multi-selection or extended-selection mode
+If you enable multi-selection, \c Multi, mode, it is possible to
+specify whether or not this mode should be extended. \c Extended
+means that the user can select multiple items only when pressing
+the Shift or Ctrl key at the same time.
+The default selection mode is \c Single.
+\sa selectionMode()
+*/
+void Q3ListView::setMultiSelection(bool enable)
+{
+if (!enable)
+d->selectionMode = Q3ListView::Single;
+else if ( d->selectionMode != Multi && d->selectionMode != Extended)
+d->selectionMode = Q3ListView::Multi;
+}
+bool Q3ListView::isMultiSelection() const
+{
+return d->selectionMode == Q3ListView::Extended || d->selectionMode == Q3ListView::Multi;
+}
+/*!
+\property Q3ListView::selectionMode
+\brief the list view's selection mode
+The mode can be \c Single (the default), \c Extended, \c Multi or
+\c NoSelection.
+\sa multiSelection
+*/
+void Q3ListView::setSelectionMode(SelectionMode mode)
+{
+if (d->selectionMode == mode)
+return;
+if ((d->selectionMode == Multi || d->selectionMode == Extended) &&
+(mode == Q3ListView::Single || mode == Q3ListView::NoSelection)){
+clearSelection();
+if ((mode == Q3ListView::Single) && currentItem())
+currentItem()->selected = true;
+}
+d->selectionMode = mode;
+}
+Q3ListView::SelectionMode Q3ListView::selectionMode() const
+{
+return d->selectionMode;
+}
+/*!
+If \a selected is true the \a item is selected; otherwise it is
+unselected.
+If the list view is in \c Single selection mode and \a selected is
+true, the currently selected item is unselected and \a item is
+made current. Unlike Q3ListViewItem::setSelected(), this function
+updates the list view as necessary and emits the
+selectionChanged() signals.
+\sa isSelected() setMultiSelection() isMultiSelection()
+setCurrentItem(), setSelectionAnchor()
+*/
+void Q3ListView::setSelected(Q3ListViewItem * item, bool selected)
+{
+if (!item || item->isSelected() == selected ||
+!item->isSelectable() || selectionMode() == NoSelection)
+return;
+bool emitHighlighted = false;
+if (selectionMode() == Single && d->focusItem != item) {
+Q3ListViewItem *o = d->focusItem;
+if (d->focusItem && d->focusItem->selected)
+d->focusItem->setSelected(false);
+d->focusItem = item;
+if (o)
+repaintItem(o);
+emitHighlighted = true;
+}
+item->setSelected(selected);
+repaintItem(item);
+if (d->selectionMode == Single && selected)
+emit selectionChanged(item);
+emit selectionChanged();
+if (emitHighlighted)
+emit currentChanged(d->focusItem);
+}
+/*!
+Sets the selection anchor to \a item, if \a item is selectable.
+The selection anchor is the item that remains selected when
+Shift-selecting with either mouse or keyboard in \c Extended
+selection mode.
+\sa setSelected()
+*/
+void Q3ListView::setSelectionAnchor(Q3ListViewItem *item)
+{
+if (item && item->isSelectable())
+d->selectAnchor = item;
+}
+/*!
+Sets all the items to be not selected, updates the list view as
+necessary, and emits the selectionChanged() signals. Note that for
+\c Multi selection list views this function needs to iterate over
+\e all items.
+\sa setSelected(), setMultiSelection()
+*/
+void Q3ListView::clearSelection()
+{
+selectAll(false);
+}
+/*!
+If \a select is true, all the items get selected; otherwise all
+the items get unselected. This only works in the selection modes \c
+Multi and \c Extended. In \c Single and \c NoSelection mode the
+selection of the current item is just set to \a select.
+*/
+void Q3ListView::selectAll(bool select)
+{
+if (d->selectionMode == Multi || d->selectionMode == Extended) {
+bool b = signalsBlocked();
+blockSignals(true);
+bool anything = false;
+Q3ListViewItemIterator it(this);
+while (it.current()) {
+Q3ListViewItem *i = it.current();
+if ((bool)i->selected != select) {
+i->setSelected(select);
+anything = true;
+}
+++it;
+}
+blockSignals(b);
+if (anything) {
+emit selectionChanged();
+triggerUpdate();
+}
+} else if (d->focusItem) {
+Q3ListViewItem * i = d->focusItem;
+setSelected(i, select);
+}
+}
+/*!
+Inverts the selection. Only works in \c Multi and \c Extended
+selection modes.
+*/
+void Q3ListView::invertSelection()
+{
+if (d->selectionMode == Single ||
+d->selectionMode == NoSelection)
+return;
+bool b = signalsBlocked();
+blockSignals(true);
+Q3ListViewItemIterator it(this);
+for (; it.current(); ++it)
+it.current()->setSelected(!it.current()->isSelected());
+blockSignals(b);
+emit selectionChanged();
+triggerUpdate();
+}
+/*!
+Returns true if the list view item \a i is selected; otherwise
+returns false.
+\sa Q3ListViewItem::isSelected()
+*/
+bool Q3ListView::isSelected(const Q3ListViewItem * i) const
+{
+return i ? i->isSelected() : false;
+}
+/*!
+Returns the selected item if the list view is in \c Single
+selection mode and an item is selected.
+If no items are selected or the list view is not in \c Single
+selection mode this function returns 0.
+\sa setSelected() setMultiSelection()
+*/
+Q3ListViewItem * Q3ListView::selectedItem() const
+{
+if (d->selectionMode != Single)
+return 0;
+if (d->focusItem && d->focusItem->isSelected())
+return d->focusItem;
+return 0;
+}
+/*!
+Sets item \a i to be the current item and repaints appropriately
+(i.e. highlights the item). The current item is used for keyboard
+navigation and focus indication; it is independent of any selected
+items, although a selected item can also be the current item.
+\sa currentItem() setSelected()
+*/
+void Q3ListView::setCurrentItem(Q3ListViewItem * i)
+{
+if (!i || d->focusItem == i || !i->isEnabled())
+return;
+if (currentItem() && currentItem()->renameBox) {
+if (d->defRenameAction == Reject)
+currentItem()->cancelRename(currentItem()->renameCol);
+else
+currentItem()->okRename(currentItem()->renameCol);
+}
+Q3ListViewItem * prev = d->focusItem;
+d->focusItem = i;
+if (i != prev) {
+if (i && d->selectionMode == Single) {
+bool changed = false;
+if (prev && prev->selected) {
+changed = true;
+prev->setSelected(false);
+}
+if (i && !i->selected && d->selectionMode != NoSelection && i->isSelectable()) {
+i->setSelected(true);
+changed = true;
+emit selectionChanged(i);
+}
+if (changed)
+emit selectionChanged();
+}
+if (i)
+repaintItem(i);
+if (prev)
+repaintItem(prev);
+emit currentChanged(i);
+#ifndef QT_NO_ACCESSIBILITY
+QAccessible::updateAccessibility(viewport(), indexOfItem(i), QAccessible::Focus);
+#endif
+}
+}
+/*!
+Returns the current item, or 0 if there isn't one.
+\sa setCurrentItem()
+*/
+Q3ListViewItem * Q3ListView::currentItem() const
+{
+return d->focusItem;
+}
+/*!
+Returns the rectangle on the screen that item \a item occupies in
+viewport()'s coordinates, or an invalid rectangle if \a item is 0 or
+is not currently visible.
+The rectangle returned does not include any children of the
+rectangle (i.e. it uses Q3ListViewItem::height(), rather than
+Q3ListViewItem::totalHeight()). If you want the rectangle to
+include children you can use something like this:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 5
+Note the way it avoids too-high rectangles. totalHeight() can be
+much larger than the window system's coordinate system allows.
+itemRect() is comparatively slow. It's best to call it only for
+items that are probably on-screen.
+*/
+QRect Q3ListView::itemRect(const Q3ListViewItem * item) const
+{
+if (d->drawables.isEmpty())
+buildDrawableList();
+for (int i = 0; i < d->drawables.size(); ++i) {
+const Q3ListViewPrivate::DrawableItem &c = d->drawables.at(i);
+if (c.i == item) {
+int y = c.y - contentsY();
+if (y + c.i->height() >= 0 && y < ((Q3ListView *)this)->visibleHeight()) {
+return QRect(-contentsX(), y, d->h->width(), c.i->height());;
+}
+}
+}
+return QRect(0, 0, -1, -1);
+}
+/*!
+\fn void Q3ListView::doubleClicked(Q3ListViewItem *item)
+This signal is emitted whenever an item is double-clicked. It's
+emitted on the second button press, not the second button release.
+\a item is the list view item on which the user did the
+double-click.
+*/
+/*!
+\fn void Q3ListView::doubleClicked(Q3ListViewItem *item, const
+QPoint& point, int column)
+This signal is emitted when a double-click occurs. It's emitted on
+the second button press, not the second button release. The \a
+item is the Q3ListViewItem the button was double-clicked on (which
+could be 0 if it wasn't double-clicked on an item). The \a point
+where the double-click occurred is given in global coordinates. If
+an item was double-clicked on, \a column is the column within the
+item that was double-clicked; otherwise \a column is -1.
+\warning Do not delete any Q3ListViewItem objects in slots
+connected to this signal.
+*/
+/*!
+\fn void Q3ListView::returnPressed(Q3ListViewItem *item)
+This signal is emitted when Enter or Return is pressed. The
+\a item parameter is the currentItem().
+*/
+/*!
+\fn void Q3ListView::spacePressed(Q3ListViewItem *item)
+This signal is emitted when Space is pressed. The \a item
+parameter is the currentItem().
+*/
+/*!
+Sets the list view to be sorted by column \a column in ascending
+order if \a ascending is true or descending order if it is false.
+If \a column is -1, sorting is disabled and the user cannot sort
+columns by clicking on the column headers. If \a column is larger
+than the number of columns the user must click on a column
+header to sort the list view.
+*/
+void Q3ListView::setSorting(int column, bool ascending)
+{
+if (column == -1)
+column = Unsorted;
+if (d->sortcolumn == column && d->ascending == ascending)
+return;
+d->ascending = ascending;
+d->sortcolumn = column;
+if (d->sortcolumn != Unsorted && d->sortIndicator)
+d->h->setSortIndicator(d->sortcolumn, d->ascending);
+else
+d->h->setSortIndicator(-1);
+triggerUpdate();
+#ifndef QT_NO_ACCESSIBILITY
+QAccessible::updateAccessibility(viewport(), 0, QAccessible::ObjectReorder);
+#endif
+}
+/*!
+Sets the \a column the list view is sorted by.
+Sorting is triggered by choosing a header section.
+*/
+void Q3ListView::changeSortColumn(int column)
+{
+if (isRenaming()) {
+if (d->defRenameAction == Q3ListView::Reject) {
+currentItem()->cancelRename(currentItem()->renameCol);
+} else {
+currentItem()->okRename(currentItem()->renameCol);
+}
+}
+if (d->sortcolumn != Unsorted) {
+int lcol = d->h->mapToLogical(column);
+setSorting(lcol, d->sortcolumn == lcol ? !d->ascending : true);
+}
+}
+/*!
+\internal
+Handles renaming when sections are being swapped by the user.
+*/
+void Q3ListView::handleIndexChange()
+{
+if (isRenaming()) {
+if (d->defRenameAction == Q3ListView::Reject) {
+currentItem()->cancelRename(currentItem()->renameCol);
+} else {
+currentItem()->okRename(currentItem()->renameCol);
+}
+}
+triggerUpdate();
+}
+/*!
+Returns the column by which the list view is sorted, or -1 if
+sorting is disabled.
+\sa sortOrder()
+*/
+int Q3ListView::sortColumn() const
+{
+return d->sortcolumn;
+}
+/*!
+Sets the sorting column for the list view.
+If \a column is -1, sorting is disabled and the user cannot sort
+columns by clicking on the column headers. If \a column is larger
+than the number of columns the user must click on a column header
+to sort the list view.
+\sa setSorting()
+*/
+void Q3ListView::setSortColumn(int column)
+{
+setSorting(column, d->ascending);
+}
+/*!
+Returns the sorting order of the list view items.
+\sa sortColumn()
+*/
+Qt::SortOrder Q3ListView::sortOrder() const
+{
+if (d->ascending)
+return Qt::AscendingOrder;
+return Qt::DescendingOrder;
+}
+/*!
+Sets the sort order for the items in the list view to \a order.
+\sa setSorting()
+*/
+void Q3ListView::setSortOrder(Qt::SortOrder order)
+{
+setSorting(d->sortcolumn, order == Qt::AscendingOrder ? true : false);
+}
+/*!
+Sorts the list view using the last sorting configuration (sort
+column and ascending/descending).
+*/
+void Q3ListView::sort()
+{
+if (d->r)
+d->r->sort();
+}
+/*!
+\property Q3ListView::itemMargin
+\brief the advisory item margin that list items may use
+The item margin defaults to one pixel and is the margin between
+the item's edges and the area where it draws its contents.
+Q3ListViewItem::paintFocus() draws in the margin.
+\sa Q3ListViewItem::paintCell()
+*/
+void Q3ListView::setItemMargin(int m)
+{
+if (d->margin == m)
+return;
+d->margin = m;
+if (isVisible()) {
+d->drawables.clear();
+triggerUpdate();
+}
+}
+int Q3ListView::itemMargin() const
+{
+return d->margin;
+}
+/*!
+\fn void Q3ListView::rightButtonClicked(Q3ListViewItem *item,
+const QPoint& point, int column)
+This signal is emitted when the right button is clicked. The \a
+item is the Q3ListViewItem the button was clicked on (which could
+be 0 if it wasn't clicked on an item). The \a point where the
+click occurred is given in global coordinates. If an item was
+clicked on, \a column is the column within the item that was
+clicked; otherwise \a column is -1.
+*/
+/*!
+\fn void Q3ListView::rightButtonPressed (Q3ListViewItem *item,
+const QPoint &point, int column)
+This signal is emitted when the right button is pressed. The \a
+item is the Q3ListViewItem the button was pressed on (which could
+be 0 if it wasn't pressed on an item). The \a point where the
+press occurred is given in global coordinates. If an item was
+pressed on, \a column is the column within the item that was
+pressed; otherwise \a column is -1.
+*/
+/*!
+\fn void Q3ListView::contextMenuRequested(Q3ListViewItem *item, const QPoint & pos, int col)
+This signal is emitted when the user invokes a context menu with
+the right mouse button or with special system keys. If the
+keyboard was used \a item is the current item; if the mouse was
+used, \a item is the item under the mouse pointer or 0 if there is
+no item under the mouse pointer. If no item is clicked, the column
+index emitted is -1.
+\a pos is the position for the context menu in the global
+coordinate system.
+\a col is the column on which the user pressed, or -1 if the
+signal was triggered by a key event.
+*/
+/*!
+\reimp
+*/
+void Q3ListView::changeEvent(QEvent *ev)
+{
+if(ev->type() == QEvent::StyleChange) {
+reconfigureItems();
+} else if(ev->type() == QEvent::ActivationChange) {
+if (!isActiveWindow() && d->scrollTimer)
+d->scrollTimer->stop();
+if (!palette().isEqual(QPalette::Active, QPalette::Inactive))
+viewport()->update();
+}
+Q3ScrollView::changeEvent(ev);
+if (ev->type() == QEvent::ApplicationFontChange || ev->type() == QEvent::FontChange
+|| ev->type() == QEvent::ApplicationPaletteChange || ev->type() == QEvent::PaletteChange)
+reconfigureItems();
+}
+/*!
+Ensures that setup() is called for all currently visible items,
+and that it will be called for currently invisible items as soon
+as their parents are opened.
+(A visible item, here, is an item whose parents are all open. The
+item may happen to be off-screen.)
+\sa Q3ListViewItem::setup()
+*/
+void Q3ListView::reconfigureItems()
+{
+d->fontMetricsHeight = fontMetrics().height();
+d->minLeftBearing = fontMetrics().minLeftBearing();
+d->minRightBearing = fontMetrics().minRightBearing();
+d->ellipsisWidth = fontMetrics().width(QLatin1String("...")) * 2;
+d->r->setOpen(false);
+d->r->configured = false;
+d->r->setOpen(true);
+}
+/*!
+Ensures that the width mode of column \a c is updated according to
+the width of \a item.
+*/
+void Q3ListView::widthChanged(const Q3ListViewItem* item, int c)
+{
+if (c >= d->h->count())
+return;
+QFontMetrics fm = fontMetrics();
+int col = c < 0 ? 0 : c;
+while (col == c || (c < 0 && col < d->h->count())) {
+if (d->column[col].wmode == Maximum) {
+int w = item->width(fm, this, col);
+if (showSortIndicator()) {
+int tw = d->h->sectionSizeHint( col, fm ).width();
+tw += 40; //add space for the sort indicator
+w = qMax(w, tw);
+}
+if (col == 0) {
+int indent = treeStepSize() * item->depth();
+if (rootIsDecorated())
+indent += treeStepSize();
+w += indent;
+}
+if (w > columnWidth(col) && !d->h->isStretchEnabled() && !d->h->isStretchEnabled(col)) {
+d->updateHeader = true;
+setColumnWidth(col, w);
+}
+}
+col++;
+}
+}
+/*!
+\property Q3ListView::allColumnsShowFocus
+\brief whether items should show keyboard focus using all columns
+If this property is true all columns will show focus and selection
+states, otherwise only column 0 will show focus.
+The default is false.
+Setting this to true if it's not necessary may cause noticeable
+flicker.
+*/
+void Q3ListView::setAllColumnsShowFocus(bool enable)
+{
+d->allColumnsShowFocus = enable;
+}
+bool Q3ListView::allColumnsShowFocus() const
+{
+return d->allColumnsShowFocus;
+}
+/*!
+Returns the first item in this Q3ListView. Returns 0 if there is no
+first item.
+A list view's items can be traversed using firstChild()
+and nextSibling() or using a Q3ListViewItemIterator.
+\sa itemAt() Q3ListViewItem::itemBelow() Q3ListViewItem::itemAbove()
+*/
+Q3ListViewItem * Q3ListView::firstChild() const
+{
+if (!d->r)
+return 0;
+d->r->enforceSortOrder();
+return d->r->childItem;
+}
+/*!
+Returns the last item in the list view tree. Returns 0 if there
+are no items in the Q3ListView.
+This function is slow because it traverses the entire tree to find
+the last item.
+*/
+Q3ListViewItem* Q3ListView::lastItem() const
+{
+Q3ListViewItem* item = firstChild();
+if (item) {
+while (item->nextSibling() || item->firstChild()) {
+if (item->nextSibling())
+item = item->nextSibling();
+else
+item = item->firstChild();
+}
+}
+return item;
+}
+/*!
+Repaints this item on the screen if it is currently visible.
+*/
+void Q3ListViewItem::repaint() const
+{
+Q3ListView *lv = listView();
+if (lv)
+lv->repaintItem(this);
+}
+/*!
+Repaints \a item on the screen if \a item is currently visible.
+Takes care to avoid multiple repaints.
+*/
+void Q3ListView::repaintItem(const Q3ListViewItem * item) const
+{
+if (!item)
+return;
+d->dirtyItemTimer->start(0, true);
+d->dirtyItems.append(item);
+}
+struct Q3CheckListItemPrivate
+{
+Q3CheckListItemPrivate():
+exclusive(0),
+currentState(Q3CheckListItem::Off),
+tristate(false) {}
+Q3CheckListItem *exclusive;
+Q3CheckListItem::ToggleState currentState;
+QHash<Q3CheckListItem *, Q3CheckListItem::ToggleState> statesDict;
+bool tristate;
+};
+/*!
+\class Q3CheckListItem
+\brief The Q3CheckListItem class provides checkable list view items.
+\compat
+Q3CheckListItems are used in \l{Q3ListView}s to provide
+\l{Q3ListViewItem}s that are checkboxes, radio buttons or
+controllers.
+Checkbox and controller check list items may be inserted at any
+level in a list view. Radio button check list items must be
+children of a controller check list item.
+The item can be checked or unchecked with setOn(). Its type can be
+retrieved with type() and its text retrieved with text().
+\img qlistviewitems.png List View Items
+\sa Q3ListViewItem Q3ListView
+*/
+/*!
+\enum Q3CheckListItem::Type
+This enum type specifies a Q3CheckListItem's type:
+\value RadioButton
+\value CheckBox
+\value RadioButtonController
+\value CheckBoxController
+\omitvalue Controller
+*/
+/*!
+\enum Q3CheckListItem::ToggleState
+This enum specifies a Q3CheckListItem's toggle state.
+\value Off
+\value NoChange
+\value On
+*/
+/*!
+Constructs a checkable item with parent \a parent, text \a text
+and of type \a tt. Note that a \c RadioButton must be the child of a
+\c RadioButtonController, otherwise it will not toggle.
+*/
+Q3CheckListItem::Q3CheckListItem(Q3CheckListItem *parent, const QString &text,
+Type tt)
+: Q3ListViewItem(parent, text, QString())
+{
+myType = tt;
+init();
+if (myType == RadioButton) {
+if (parent->type() != RadioButtonController)
+qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be "
+"child of a controller");
+else
+d->exclusive = parent;
+}
+}
+/*!
+Constructs a checkable item with parent \a parent, which is after
+\a after in the parent's list of children, and with text \a text
+and of type \a tt. Note that a \c RadioButton must be the child of
+a \c RadioButtonController, otherwise it will not toggle.
+*/
+Q3CheckListItem::Q3CheckListItem(Q3CheckListItem *parent, Q3ListViewItem *after,
+const QString &text, Type tt)
+: Q3ListViewItem(parent, after, text)
+{
+myType = tt;
+init();
+if (myType == RadioButton) {
+if (parent->type() != RadioButtonController)
+qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be "
+"child of a controller");
+else
+d->exclusive = parent;
+}
+}
+/*!
+Constructs a checkable item with parent \a parent, text \a text
+and of type \a tt. Note that this item must \e not be a \c
+RadioButton. Radio buttons must be children of a \c
+RadioButtonController.
+*/
+Q3CheckListItem::Q3CheckListItem(Q3ListViewItem *parent, const QString &text,
+Type tt)
+: Q3ListViewItem(parent, text, QString())
+{
+myType = tt;
+if (myType == RadioButton) {
+qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be "
+"child of a Q3CheckListItem");
+}
+init();
+}
+/*!
+Constructs a checkable item with parent \a parent, which is after
+\a after in the parent's list of children, with text \a text and
+of type \a tt. Note that this item must \e not be a \c
+RadioButton. Radio buttons must be children of a \c
+RadioButtonController.
+*/
+Q3CheckListItem::Q3CheckListItem(Q3ListViewItem *parent, Q3ListViewItem *after,
+const QString &text, Type tt)
+: Q3ListViewItem(parent, after, text)
+{
+myType = tt;
+if (myType == RadioButton) {
+qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be "
+"child of a Q3CheckListItem");
+}
+init();
+}
+/*!
+Constructs a checkable item with parent \a parent, text \a text
+and of type \a tt. Note that \a tt must \e not be \c RadioButton.
+Radio buttons must be children of a \c RadioButtonController.
+*/
+Q3CheckListItem::Q3CheckListItem(Q3ListView *parent, const QString &text,
+Type tt)
+: Q3ListViewItem(parent, text)
+{
+myType = tt;
+if (tt == RadioButton)
+qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be "
+"child of a Q3CheckListItem");
+init();
+}
+/*!
+Constructs a checkable item with parent \a parent, which is after
+\a after in the parent's list of children, with text \a text and
+of type \a tt. Note that \a tt must \e not be \c RadioButton.
+Radio buttons must be children of a \c RadioButtonController.
+*/
+Q3CheckListItem::Q3CheckListItem(Q3ListView *parent, Q3ListViewItem *after,
+const QString &text, Type tt)
+: Q3ListViewItem(parent, after, text)
+{
+myType = tt;
+if (tt == RadioButton)
+qWarning("Q3CheckListItem::Q3CheckListItem(), radio button must be "
+"child of a Q3CheckListItem");
+init();
+}
+/* \reimp */
+int Q3CheckListItem::rtti() const
+{
+return RTTI;
+}
+/*!
+Constructs a \c RadioButtonController item with parent \a parent,
+text \a text and pixmap \a p.
+*/
+Q3CheckListItem::Q3CheckListItem(Q3ListView *parent, const QString &text,
+const QPixmap & p)
+: Q3ListViewItem(parent, text)
+{
+myType = RadioButtonController;
+setPixmap(0, p);
+init();
+}
+/*!
+Constructs a \c RadioButtonController item with parent \a parent,
+text \a text and pixmap \a p.
+*/
+Q3CheckListItem::Q3CheckListItem(Q3ListViewItem *parent, const QString &text,
+const QPixmap & p)
+: Q3ListViewItem(parent, text)
+{
+myType = RadioButtonController;
+setPixmap(0, p);
+init();
+}
+void Q3CheckListItem::init()
+{
+d = new Q3CheckListItemPrivate();
+on = false;
+// CheckBoxControllers by default have tristate set to true
+if (myType == CheckBoxController)
+setTristate(true);
+}
+/*!
+Destroys the item, and all its children to any depth, freeing up
+all allocated resources.
+*/
+Q3CheckListItem::~Q3CheckListItem()
+{
+if (myType == RadioButton
+&& d->exclusive && d->exclusive->d
+&& d->exclusive->d->exclusive == this)
+d->exclusive->turnOffChild();
+d->exclusive = 0; // so the children won't try to access us.
+delete d;
+d = 0;
+}
+/*!
+\fn Q3CheckListItem::Type Q3CheckListItem::type() const
+Returns the type of this item.
+*/
+/*!
+\fn  bool Q3CheckListItem::isOn() const
+Returns true if the item is toggled on; otherwise returns false.
+*/
+/*!
+Sets tristate to \a b if the \c Type is either a \c CheckBoxController or
+a \c CheckBox.
+\c CheckBoxControllers are tristate by default.
+\sa state() isTristate()
+*/
+void Q3CheckListItem::setTristate(bool b)
+{
+if ((myType != CheckBoxController) && (myType != CheckBox)) {
+qWarning("Q3CheckListItem::setTristate(), has no effect on RadioButton "
+"or RadioButtonController.");
+return;
+}
+d->tristate = b;
+}
+/*!
+Returns true if the item is tristate; otherwise returns false.
+\sa setTristate()
+*/
+bool Q3CheckListItem::isTristate() const
+{
+return d->tristate;
+}
+/*!
+Returns the state of the item.
+\sa Q3CheckListItem::ToggleState
+*/
+Q3CheckListItem::ToggleState Q3CheckListItem::state() const
+{
+if (!isTristate() && internalState() == NoChange)
+return Off;
+else
+return d->currentState;
+}
+/*
+Same as the public state() except this one does not mask NoChange into Off
+when tristate is disabled.
+*/
+Q3CheckListItem::ToggleState Q3CheckListItem::internalState() const
+{
+return d->currentState;
+}
+/*!
+Sets the toggle state of the checklistitem to \a s. \a s can be
+\c Off, \c NoChange or \c On.
+Tristate can only be enabled for \c CheckBox or \c CheckBoxController,
+therefore the \c NoChange only applies to them.
+Setting the state to \c On or \c Off on a \c CheckBoxController
+will recursivly set the states of its children to the same state.
+Setting the state to \c NoChange on a \c CheckBoxController will
+make it recursivly recall the previous stored state of its
+children. If there was no previous stored state the children are
+all set to \c On.
+*/
+void Q3CheckListItem::setState(ToggleState s)
+{
+if (myType == CheckBoxController && state() == NoChange)
+updateStoredState(this);
+setState(s, true, true);
+}
+/*
+Sets the toggle state of the checklistitems. \a update tells if the
+controller / parent controller should be aware of these changes, \a store
+tells if the parent should store its children if certain conditions arise
+*/
+void Q3CheckListItem::setState(ToggleState s, bool update, bool store)
+{
+if (s == internalState())
+return;
+if (myType == CheckBox) {
+setCurrentState(s);
+stateChange(state());
+if (update && parent() && parent()->rtti() == 1
+&& ((Q3CheckListItem*)parent())->type() == CheckBoxController)
+((Q3CheckListItem*)parent())->updateController(update, store);
+} else if (myType == CheckBoxController) {
+if (s == NoChange && childCount()) {
+restoreState(this);
+} else {
+Q3ListViewItem *item = firstChild();
+int childCount = 0;
+while(item) {
+if (item->rtti() == 1 &&
+(((Q3CheckListItem*)item)->type() == CheckBox ||
+((Q3CheckListItem*)item)->type() == CheckBoxController)) {
+Q3CheckListItem *checkItem = (Q3CheckListItem*)item;
+checkItem->setState(s, false, false);
+childCount++;
+}
+item = item->nextSibling();
+}
+if (update) {
+if (childCount > 0) {
+ToggleState oldState = internalState();
+updateController(false, false);
+if (oldState != internalState() &&
+parent() && parent()->rtti() == 1 &&
+((Q3CheckListItem*)parent())->type() == CheckBoxController)
+((Q3CheckListItem*)parent())->updateController(update, store);
+updateController(update, store);
+} else {
+// if there are no children we simply set the CheckBoxController and update its parent
+setCurrentState(s);
+stateChange(state());
+if (parent() && parent()->rtti() == 1
+&& ((Q3CheckListItem*)parent())->type() == CheckBoxController)
+((Q3CheckListItem*)parent())->updateController(update, store);
+}
+} else {
+setCurrentState(s);
+stateChange(state());
+}
+}
+} else if (myType == RadioButton) {
+if (s == On) {
+if (d->exclusive && d->exclusive->d->exclusive != this)
+d->exclusive->turnOffChild();
+setCurrentState(s);
+if (d->exclusive)
+d->exclusive->d->exclusive = this;
+} else {
+if (d->exclusive && d->exclusive->d->exclusive == this)
+d->exclusive->d->exclusive = 0;
+setCurrentState(Off);
+}
+stateChange(state());
+}
+repaint();
+}
+/*
+this function is needed because we need to update "on" every time we
+update d->currentState. In order to retain binary compatibility the
+inline function isOn() needs the "on" bool ### should be changed in
+ver 4
+*/
+void Q3CheckListItem::setCurrentState(ToggleState s)
+{
+ToggleState old = d->currentState;
+d->currentState = s;
+if (d->currentState == On)
+on = true;
+else
+on = false;
+#ifndef QT_NO_ACCESSIBILITY
+if (old != d->currentState && listView())
+QAccessible::updateAccessibility(listView()->viewport(), indexOfItem(this), QAccessible::StateChanged);
+#else
+Q_UNUSED(old);
+#endif
+}
+/*
+updates the internally stored state of this item for the parent (key)
+*/
+void Q3CheckListItem::setStoredState(ToggleState newState, Q3CheckListItem *key)
+{
+if (myType == CheckBox || myType == CheckBoxController)
+d->statesDict[key] = newState;
+}
+/*
+Returns the stored state for this item for the given key.
+If the key is not found it returns Off.
+*/
+Q3CheckListItem::ToggleState Q3CheckListItem::storedState(Q3CheckListItem *key) const
+{
+QHash<Q3CheckListItem *, Q3CheckListItem::ToggleState>::Iterator it = d->statesDict.find(key);
+if (it != d->statesDict.end())
+return it.value();
+else
+return Off;
+}
+/*!
+\fn QString Q3CheckListItem::text() const
+Returns the item's text.
+*/
+/*!
+If this is a \c RadioButtonController that has \c RadioButton
+children, turn off the child that is on.
+*/
+void Q3CheckListItem::turnOffChild()
+{
+if (myType == RadioButtonController && d->exclusive)
+d->exclusive->setOn(false);
+}
+/*!
+Toggle check box or set radio button to on.
+*/
+void Q3CheckListItem::activate()
+{
+Q3ListView * lv = listView();
+if ((lv && !lv->isEnabled()) || !isEnabled())
+return;
+QPoint pos;
+int boxsize = lv->style()->pixelMetric(QStyle::PM_CheckListButtonSize, 0, lv);
+if (activatedPos(pos)) {
+bool parentControl = false;
+if (parent() && parent()->rtti() == 1  &&
+((Q3CheckListItem*) parent())->type() == RadioButtonController)
+parentControl = true;
+int x = parentControl ? 0 : 3;
+int align = lv->columnAlignment(0);
+int marg = lv->itemMargin();
+int y = 0;
+if (align & Qt::AlignVCenter)
+y = ((height() - boxsize) / 2) + marg;
+else
+y = (lv->fontMetrics().height() + 2 + marg - boxsize) / 2;
+QRect r(x, y, boxsize-3, boxsize-3);
+// columns might have been swapped
+r.moveBy(lv->header()->sectionPos(0), 0);
+if (!r.contains(pos))
+return;
+}
+if ((myType == CheckBox) || (myType == CheckBoxController))  {
+lv->d->startEdit = FALSE;
+switch (internalState()) {
+case On:
+setState(Off);
+break;
+case Off:
+	    if ( (!isTristate() && myType == CheckBox) ||
+(myType == CheckBoxController && !childCount()) ) {
+setState(On);
+} else {
+setState(NoChange);
+if (myType == CheckBoxController && internalState() != NoChange)
+setState(On);
+}
+break;
+case NoChange:
+setState(On);
+break;
+}
+ignoreDoubleClick();
+} else if (myType == RadioButton) {
+setOn(true);
+ignoreDoubleClick();
+}
+}
+/*!
+Sets the button on if \a b is true, otherwise sets it off.
+Maintains radio button exclusivity.
+*/
+void Q3CheckListItem::setOn(bool b )
+{
+if (b)
+setState(On , true, true);
+else
+setState(Off , true, true);
+}
+/*!
+\fn void Q3CheckListItem::stateChange(bool b)
+This virtual function is called when the item changes its state.
+\a b is true if the state is \c On; otherwise the state is \c Off.
+\c NoChange (if tristate is enabled and the type is either \c
+CheckBox or \c CheckBoxController) reports the same as \c Off, so
+use state() to determine if the state is actually \c Off or \c
+NoChange.
+*/
+void Q3CheckListItem::stateChange(bool)
+{
+}
+/*
+Calls the public virtual function if the state is changed to either On, NoChange or Off.
+NoChange reports the same as Off - ### should be fixed in ver4
+*/
+void Q3CheckListItem::stateChange(ToggleState s)
+{
+stateChange(s == On);
+}
+/*
+sets the state of the CheckBox and CheckBoxController back to
+previous stored state
+*/
+void Q3CheckListItem::restoreState(Q3CheckListItem *key, int depth)
+{
+switch (type()) {
+case CheckBox:
+setCurrentState(storedState(key));
+stateChange(state());
+repaint();
+break;
+case CheckBoxController: {
+Q3ListViewItem *item = firstChild();
+int childCount = 0;
+while (item) {
+// recursively calling restoreState for children of type CheckBox and CheckBoxController
+if (item->rtti() == 1 &&
+(((Q3CheckListItem*)item)->type() == CheckBox ||
+((Q3CheckListItem*)item)->type() == CheckBoxController)) {
+((Q3CheckListItem*)item)->restoreState(key , depth+1);
+childCount++;
+}
+item = item->nextSibling();
+}
+if (childCount > 0) {
+if (depth == 0)
+updateController(true);
+else
+updateController(false);
+} else {
+// if there are no children we retrieve the CheckBoxController state directly.
+setState(storedState(key), true, false);
+}
+}
+break;
+default:
+break;
+}
+}
+/*
+Checks the childrens state and updates the controllers state
+if necessary. If the controllers state change, then his parent again is
+called to update itself.
+*/
+void Q3CheckListItem::updateController(bool update , bool store)
+{
+if (myType != CheckBoxController)
+return;
+Q3CheckListItem *controller = 0;
+// checks if this CheckBoxController has another CheckBoxController as parent
+if (parent() && parent()->rtti() == 1
+&& ((Q3CheckListItem*)parent())->type() == CheckBoxController)
+controller = (Q3CheckListItem*)parent();
+ToggleState theState = Off;
+bool first = true;
+Q3ListViewItem *item = firstChild();
+while(item && theState != NoChange) {
+if (item->rtti() == 1 &&
+(((Q3CheckListItem*)item)->type() == CheckBox ||
+((Q3CheckListItem*)item)->type() == CheckBoxController)) {
+Q3CheckListItem *checkItem = (Q3CheckListItem*)item;
+if (first) {
+theState = checkItem->internalState();
+first = false;
+} else {
+if (checkItem->internalState() == NoChange ||
+theState != checkItem->internalState())
+theState = NoChange;
+else
+theState = checkItem->internalState();
+}
+}
+item = item->nextSibling();
+}
+if (internalState() != theState) {
+setCurrentState(theState);
+if (store && (internalState() == On || internalState() == Off))
+updateStoredState(this);
+stateChange(state());
+if (update && controller) {
+controller->updateController(update, store);
+}
+repaint();
+}
+}
+/*
+Makes all the children CheckBoxes update their storedState
+*/
+void Q3CheckListItem::updateStoredState(Q3CheckListItem *key)
+{
+if (myType != CheckBoxController)
+return;
+Q3ListViewItem *item = firstChild();
+while(item) {
+if (item->rtti() == 1) {
+Q3CheckListItem *checkItem = (Q3CheckListItem*)item;
+if (checkItem->type() == CheckBox)
+checkItem->setStoredState(checkItem->internalState(), key);
+else if (checkItem->type() == CheckBoxController)
+checkItem->updateStoredState(key);
+}
+item = item->nextSibling();
+}
+// this state is only needed if the CheckBoxController has no CheckBox / CheckBoxController children.
+setStoredState(internalState() , key);
+}
+/*!
+\reimp
+*/
+void Q3CheckListItem::setup()
+{
+Q3ListViewItem::setup();
+int h = height();
+Q3ListView *lv = listView();
+if (lv)
+h = qMax(lv->style()->pixelMetric(QStyle::PM_CheckListButtonSize, 0, lv),
+h);
+h = qMax(h, QApplication::globalStrut().height());
+setHeight(h);
+}
+/*!
+\reimp
+*/
+int Q3CheckListItem::width(const QFontMetrics& fm, const Q3ListView* lv, int column) const
+{
+int r = Q3ListViewItem::width(fm, lv, column);
+if (column == 0) {
+r += lv->itemMargin();
+if (myType == RadioButtonController && pixmap(0)) {
+//             r += 0;
+} else {
+r +=  lv->style()->pixelMetric(QStyle::PM_CheckListButtonSize, 0, lv) + 4;
+}
+}
+return qMax(r, QApplication::globalStrut().width());
+}
+/*!
+Paints the item using the painter \a p and the color group \a cg.
+The item is in column \a column, has width \a width and has
+alignment \a align. (See \l Qt::Alignment for valid alignments.)
+*/
+void Q3CheckListItem::paintCell(QPainter * p, const QColorGroup & cg,
+int column, int width, int align)
+{
+if (!p)
+return;
+Q3ListView *lv = listView();
+if (!lv)
+return;
+const QPalette::ColorRole crole = lv->backgroundRole();
+if (cg.brush(crole) != lv->palette().brush(cg.currentColorGroup(), crole))
+p->fillRect(0, 0, width, height(), cg.brush(crole));
+else
+lv->paintEmptyArea(p, QRect(0, 0, width, height()));
+if (column != 0) {
+// The rest is text, or for subclasses to change.
+Q3ListViewItem::paintCell(p, cg, column, width, align);
+return;
+}
+bool parentControl = false;
+if (parent() && parent()->rtti() == 1  &&
+((Q3CheckListItem*) parent())->type() == RadioButtonController)
+parentControl = true;
+QFontMetrics fm(lv->fontMetrics());
+int boxsize = lv->style()->pixelMetric(myType == RadioButtonController ? QStyle::PM_CheckListControllerSize :
+QStyle::PM_CheckListButtonSize, 0, lv);
+int marg = lv->itemMargin();
+int r = marg;
+// Draw controller / check box / radio button ---------------------
+QStyle::State styleflags = QStyle::State_None;
+if (internalState() == On) {
+styleflags |= QStyle::State_On;
+} else if (internalState() == NoChange) {
+if (myType == CheckBoxController && !isTristate())
+styleflags |= QStyle::State_Off;
+else
+styleflags |= QStyle::State_NoChange;
+} else {
+styleflags |= QStyle::State_Off;
+}
+if (isSelected())
+styleflags |= QStyle::State_Selected;
+if (isEnabled() && lv->isEnabled())
+styleflags |= QStyle::State_Enabled;
+if (lv->window()->isActiveWindow())
+styleflags |= QStyle::State_Active;
+if (myType == RadioButtonController) {
+int x = 0;
+if(!parentControl)
+x += 3;
+if (!pixmap(0)) {
+QStyleOptionQ3ListView opt = getStyleOption(lv, this);
+opt.rect.setRect(x, 0, boxsize, fm.height() + 2 + marg);
+opt.palette = cg;
+opt.state = styleflags;
+lv->style()->drawPrimitive(QStyle::PE_Q3CheckListController, &opt, p, lv);
+r += boxsize + 4;
+}
+} else {
+Q_ASSERT(lv); //###
+int x = 0;
+int y = 0;
+if (!parentControl)
+x += 3;
+if (align & Qt::AlignVCenter)
+y = ((height() - boxsize) / 2) + marg;
+else
+y = (fm.height() + 2 + marg - boxsize) / 2;
+QStyleOptionQ3ListView opt = getStyleOption(lv, this);
+opt.rect.setRect(x, y, boxsize, fm.height() + 2 + marg);
+opt.palette = cg;
+opt.state = styleflags;
+lv->style()->drawPrimitive((myType == CheckBox || myType == CheckBoxController)
+? QStyle::PE_Q3CheckListIndicator
+: QStyle::PE_Q3CheckListExclusiveIndicator, &opt, p, lv);
+r += boxsize + 4;
+}
+// Draw text ----------------------------------------------------
+p->translate(r, 0);
+p->setPen(QPen(cg.text()));
+Q3ListViewItem::paintCell(p, cg, column, width - r, align);
+}
+/*!
+Draws the focus rectangle \a r using the color group \a cg on the
+painter \a p.
+*/
+void Q3CheckListItem::paintFocus(QPainter *p, const QColorGroup & cg,
+const QRect & r)
+{
+bool intersect = true;
+Q3ListView *lv = listView();
+if (lv && lv->header()->mapToActual(0) != 0) {
+int xdepth = lv->treeStepSize() * (depth() + (lv->rootIsDecorated() ? 1 : 0)) + lv->itemMargin();
+int p = lv->header()->cellPos(lv->header()->mapToActual(0));
+xdepth += p;
+intersect = r.intersects(QRect(p, r.y(), xdepth - p + 1, r.height()));
+}
+bool parentControl = false;
+if (parent() && parent()->rtti() == 1  &&
+((Q3CheckListItem*) parent())->type() == RadioButtonController)
+parentControl = true;
+if (myType != RadioButtonController && intersect &&
+(lv->rootIsDecorated() || myType == RadioButton ||
+(myType == CheckBox && parentControl))) {
+QRect rect;
+int boxsize = lv->style()->pixelMetric(QStyle::PM_CheckListButtonSize, 0, lv);
+if (lv->columnAlignment(0) == Qt::AlignCenter) {
+QFontMetrics fm(lv->font());
+int bx = (lv->columnWidth(0) - (boxsize + fm.width(text())))/2 + boxsize;
+if (bx < 0) bx = 0;
+rect.setRect(r.x() + bx + 5, r.y(), r.width() - bx - 5,
+r.height());
+} else
+rect.setRect(r.x() + boxsize + 5, r.y(), r.width() - boxsize - 5,
+r.height());
+Q3ListViewItem::paintFocus(p, cg, rect);
+} else {
+Q3ListViewItem::paintFocus(p, cg, r);
+}
+}
+/*!
+\reimp
+*/
+QSize Q3ListView::sizeHint() const
+{
+if (cachedSizeHint().isValid())
+return cachedSizeHint();
+ensurePolished();
+if (!isVisible() && d->drawables.isEmpty())
+// force the column widths to sanity, if possible
+buildDrawableList();
+QSize s(d->h->sizeHint());
+if (verticalScrollBar()->isVisible())
+s.setWidth(s.width() + style()->pixelMetric(QStyle::PM_ScrollBarExtent));
+s += QSize(frameWidth()*2,frameWidth()*2);
+Q3ListViewItem * l = d->r;
+while(l && !l->height())
+l = l->childItem ? l->childItem : l->siblingItem;
+if (l && l->height())
+s.setHeight(s.height() + 10 * l->height());
+else
+s.setHeight(s.height() + 140);
+if (s.width() > s.height() * 3)
+s.setHeight(s.width() / 3);
+else if (s.width() *3 < s.height())
+s.setHeight(s.width() * 3);
+setCachedSizeHint(s);
+return s;
+}
+/*!
+\reimp
+*/
+QSize Q3ListView::minimumSizeHint() const
+{
+return Q3ScrollView::minimumSizeHint();
+}
+/*!
+Sets \a item to be open if \a open is true and \a item is
+expandable, and to be closed if \a open is false. Repaints
+accordingly.
+\sa Q3ListViewItem::setOpen() Q3ListViewItem::setExpandable()
+*/
+void Q3ListView::setOpen(Q3ListViewItem * item, bool open)
+{
+if (!item ||
+item->isOpen() == open ||
+(open && !item->childCount() && !item->isExpandable()))
+return;
+Q3ListViewItem* nextParent = 0;
+if (open)
+nextParent = item->itemBelow();
+item->setOpen(open);
+if (open) {
+Q3ListViewItem* lastChild = item;
+Q3ListViewItem* tmp;
+while (true) {
+tmp = lastChild->itemBelow();
+if (!tmp || tmp == nextParent)
+break;
+lastChild = tmp;
+}
+ensureItemVisible(lastChild);
+ensureItemVisible(item);
+}
+buildDrawableList();
+int i = 0;
+for (; i < d->drawables.size(); ++i) {
+const Q3ListViewPrivate::DrawableItem &c = d->drawables.at(i);
+if(c.i == item)
+break;
+}
+if (i < d->drawables.size()) {
+d->dirtyItemTimer->start(0, true);
+for (; i < d->drawables.size(); ++i) {
+const Q3ListViewPrivate::DrawableItem &c = d->drawables.at(i);
+d->dirtyItems.append(c.i);
+}
+}
+}
+/*!
+Returns true if this list view item has children \e and they are
+not explicitly hidden; otherwise returns false.
+Identical to \a{item}->isOpen(). Provided for completeness.
+\sa setOpen()
+*/
+bool Q3ListView::isOpen(const Q3ListViewItem * item) const
+{
+return item->isOpen();
+}
+/*!
+\property Q3ListView::rootIsDecorated
+\brief whether the list view shows open/close signs on root items
+Open/close signs are small \bold{+} or \bold{-} symbols in windows
+style, or arrows in Motif style. The default is false.
+*/
+void Q3ListView::setRootIsDecorated(bool enable)
+{
+if (enable != (bool)d->rootIsExpandable) {
+d->rootIsExpandable = enable;
+if (isVisible())
+triggerUpdate();
+}
+}
+bool Q3ListView::rootIsDecorated() const
+{
+return d->rootIsExpandable;
+}
+/*!
+Ensures that item \a i is visible, scrolling the list view
+vertically if necessary and opening (expanding) any parent items
+if this is required to show the item.
+\sa itemRect() Q3ScrollView::ensureVisible()
+*/
+void Q3ListView::ensureItemVisible(const Q3ListViewItem * i)
+{
+if (!i || !i->isVisible())
+return;
+Q3ListViewItem *parent = i->parent();
+while (parent) {
+if (!parent->isOpen())
+parent->setOpen(true);
+parent = parent->parent();
+}
+if (d->r->maybeTotalHeight < 0)
+updateGeometries();
+int y = itemPos(i);
+int h = i->height();
+if (isVisible() && y + h > contentsY() + visibleHeight())
+setContentsPos(contentsX(), y - visibleHeight() + h);
+else if (!isVisible() || y < contentsY())
+setContentsPos(contentsX(), y);
+}
+/*!
+\fn QString Q3CheckListItem::text(int n) const
+\reimp
+*/
+/*!
+Returns the Q3Header object that manages this list view's columns.
+Please don't modify the header behind the list view's back.
+You may safely call Q3Header::setClickEnabled(),
+Q3Header::setResizeEnabled(), Q3Header::setMovingEnabled(),
+Q3Header::hide() and all the const Q3Header functions.
+*/
+Q3Header * Q3ListView::header() const
+{
+return d->h;
+}
+/*!
+\property Q3ListView::childCount
+\brief the number of parentless (top-level) Q3ListViewItem objects in this Q3ListView
+Holds the current number of parentless (top-level) Q3ListViewItem
+objects in this Q3ListView.
+\sa Q3ListViewItem::childCount()
+*/
+int Q3ListView::childCount() const
+{
+if (d->r)
+return d->r->childCount();
+return 0;
+}
+/*
+Moves this item to just after \a olderSibling. \a olderSibling and
+this object must have the same parent.
+If you need to move an item in the hierarchy use takeItem() and
+insertItem().
+*/
+void Q3ListViewItem::moveToJustAfter(Q3ListViewItem * olderSibling)
+{
+if (parentItem && olderSibling &&
+olderSibling->parentItem == parentItem && olderSibling != this) {
+if (parentItem->childItem == this) {
+parentItem->childItem = siblingItem;
+} else {
+Q3ListViewItem * i = parentItem->childItem;
+while(i && i->siblingItem != this)
+i = i->siblingItem;
+if (i)
+i->siblingItem = siblingItem;
+}
+siblingItem = olderSibling->siblingItem;
+olderSibling->siblingItem = this;
+parentItem->lsc = Unsorted;
+}
+}
+/*!
+Move the item to be after item \a after, which must be one of the
+item's siblings. To move an item in the hierarchy, use takeItem()
+and insertItem().
+Note that this function will have no effect if sorting is enabled
+in the list view.
+*/
+void Q3ListViewItem::moveItem(Q3ListViewItem *after)
+{
+if (!after || after == this)
+return;
+if (parent() != after->parent()) {
+if (parentItem)
+parentItem->takeItem(this);
+if (after->parentItem) {
+int tmpLsc = after->parentItem->lsc;
+after->parentItem->insertItem(this);
+after->parentItem->lsc = tmpLsc;
+}
+}
+moveToJustAfter(after);
+Q3ListView *lv = listView();
+if (lv)
+lv->triggerUpdate();
+}
+/*
+Recursively sorts items, from the root to this item.
+(enforceSortOrder() won't work the other way around, as
+documented.)
+*/
+void Q3ListViewItem::enforceSortOrderBackToRoot()
+{
+if (parentItem) {
+parentItem->enforceSortOrderBackToRoot();
+parentItem->enforceSortOrder();
+}
+}
+/*!
+\reimp
+*/
+void Q3ListView::showEvent(QShowEvent *)
+{
+d->drawables.clear();
+d->dirtyItems.clear();
+d->dirtyItemTimer->stop();
+d->fullRepaintOnComlumnChange = true;
+updateGeometries();
+}
+/*!
+Returns the y coordinate of this item in the list view's
+coordinate system. This function is normally much slower than
+Q3ListView::itemAt(), but it works for all items whereas
+Q3ListView::itemAt() normally only works for items on the screen.
+\sa Q3ListView::itemAt() Q3ListView::itemRect() Q3ListView::itemPos()
+*/
+int Q3ListViewItem::itemPos() const
+{
+QStack<Q3ListViewItem *> s;
+Q3ListViewItem * i = (Q3ListViewItem *)this;
+while(i) {
+s.push(i);
+i = i->parentItem;
+}
+int a = 0;
+Q3ListViewItem * p = 0;
+while(s.count()) {
+i = s.pop();
+if (p) {
+if (!p->configured) {
+p->configured = true;
+p->setup(); // ### virtual non-const function called in const
+}
+a += p->height();
+Q3ListViewItem * s = p->firstChild();
+while(s && s != i) {
+a += s->totalHeight();
+s = s->nextSibling();
+}
+}
+p = i;
+}
+return a;
+}
+/*!
+\fn void Q3ListView::removeItem(Q3ListViewItem *item)
+Removes the given \a item. Use takeItem() instead.
+*/
+/*!
+Removes item \a i from the list view; \a i must be a top-level
+item. The warnings regarding Q3ListViewItem::takeItem() apply to
+this function, too.
+\sa insertItem()
+*/
+void Q3ListView::takeItem(Q3ListViewItem * i)
+{
+if (d->r)
+d->r->takeItem(i);
+}
+void Q3ListView::openFocusItem()
+{
+d->autoopenTimer->stop();
+if (d->focusItem && !d->focusItem->isOpen()) {
+d->focusItem->setOpen(true);
+d->focusItem->repaint();
+}
+}
+static const int autoopenTime = 750;
+#ifndef QT_NO_DRAGANDDROP
+/*! \reimp */
+void Q3ListView::contentsDragEnterEvent(QDragEnterEvent *e)
+{
+d->oldFocusItem = d->focusItem;
+Q3ListViewItem *i = d->focusItem;
+d->focusItem = itemAt(contentsToViewport(e->pos()));
+if (i)
+i->repaint();
+if (d->focusItem) {
+d->autoopenTimer->start(autoopenTime);
+d->focusItem->dragEntered();
+d->focusItem->repaint();
+}
+e->accept();
+}
+/*! \reimp */
+void Q3ListView::contentsDragMoveEvent(QDragMoveEvent *e)
+{
+Q3ListViewItem *i = d->focusItem;
+d->focusItem = itemAt(contentsToViewport(e->pos()));
+if (i) {
+if (i != d->focusItem)
+i->dragLeft();
+i->repaint();
+}
+if (d->focusItem) {
+if (i != d->focusItem) {
+d->focusItem->dragEntered();
+d->autoopenTimer->stop();
+d->autoopenTimer->start(autoopenTime);
+}
+d->focusItem->repaint();
+} else {
+d->autoopenTimer->stop();
+}
+if ((i && i->dropEnabled() && i->acceptDrop(e)) || acceptDrops())
+e->accept();
+else
+e->ignore();
+}
+/*! \reimp */
+void Q3ListView::contentsDragLeaveEvent(QDragLeaveEvent *)
+{
+d->autoopenTimer->stop();
+if (d->focusItem)
+d->focusItem->dragLeft();
+setCurrentItem(d->oldFocusItem);
+d->oldFocusItem = 0;
+}
+/*! \reimp */
+void Q3ListView::contentsDropEvent(QDropEvent *e)
+{
+d->autoopenTimer->stop();
+setCurrentItem(d->oldFocusItem);
+Q3ListViewItem *i = itemAt(contentsToViewport(e->pos()));
+if (i && i->dropEnabled() && i->acceptDrop(e)) {
+i->dropped(e);
+e->accept();
+} else if (acceptDrops()) {
+emit dropped(e);
+e->accept();
+}
+}
+/*!
+If the user presses the mouse on an item and starts moving the
+mouse, and the item allow dragging (see
+Q3ListViewItem::setDragEnabled()), this function is called to get a
+drag object and a drag is started unless dragObject() returns 0.
+By default this function returns 0. You should reimplement it and
+create a Q3DragObject depending on the selected items.
+*/
+Q3DragObject *Q3ListView::dragObject()
+{
+return 0;
+}
+/*!
+Starts a drag.
+*/
+void Q3ListView::startDrag()
+{
+if (!d->startDragItem)
+return;
+d->startDragItem = 0;
+d->buttonDown = false;
+Q3DragObject *drag = dragObject();
+if (!drag)
+return;
+drag->drag();
+}
+#endif // QT_NO_DRAGANDDROP
+/*!
+\property Q3ListView::defaultRenameAction
+\brief What action to perform when the editor loses focus during renaming
+If this property is \c Accept, and the user renames an item and
+the editor loses focus (without the user pressing Enter), the
+item will still be renamed. If the property's value is \c Reject,
+the item will not be renamed unless the user presses Enter. The
+default is \c Reject.
+*/
+void Q3ListView::setDefaultRenameAction(RenameAction a)
+{
+d->defRenameAction = a;
+}
+Q3ListView::RenameAction Q3ListView::defaultRenameAction() const
+{
+return d->defRenameAction;
+}
+/*!
+Returns true if an item is being renamed; otherwise returns false.
+*/
+bool Q3ListView::isRenaming() const
+{
+return currentItem() && currentItem()->renameBox;
+}
+/**********************************************************************
+*
+* Class Q3ListViewItemIterator
+*
+**********************************************************************/
+/*!
+\class Q3ListViewItemIterator
+\brief The Q3ListViewItemIterator class provides an iterator for collections of Q3ListViewItems.
+\compat
+Construct an instance of a Q3ListViewItemIterator, with either a
+Q3ListView* or a Q3ListViewItem* as argument, to operate on the tree
+of Q3ListViewItems, starting from the argument.
+A Q3ListViewItemIterator iterates over all the items from its
+starting point. This means that it always makes the first child of
+the current item the new current item. If there is no child, the
+next sibling becomes the new current item; and if there is no next
+sibling, the next sibling of the parent becomes current.
+The following example creates a list of all the items that have
+been selected by the user, storing pointers to the items in a
+QList:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 6
+An alternative approach is to use an \c IteratorFlag:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3listview.cpp 7
+A Q3ListViewItemIterator provides a convenient and easy way to
+traverse a hierarchical Q3ListView.
+Multiple Q3ListViewItemIterators can operate on the tree of
+Q3ListViewItems. A Q3ListView knows about all iterators operating on
+its Q3ListViewItems. So when a Q3ListViewItem gets removed all
+iterators that point to this item are updated and point to the
+following item if possible, otherwise to a valid item before the
+current one or to 0. Note however that deleting the parent item of
+an item that an iterator points to is not safe.
+\sa Q3ListView, Q3ListViewItem
+*/
+/*!
+\enum Q3ListViewItemIterator::IteratorFlag
+These flags can be passed to a Q3ListViewItemIterator constructor
+(OR-ed together if more than one is used), so that the iterator
+will only iterate over items that match the given flags.
+\value Visible
+\value Invisible
+\value Selected
+\value Unselected
+\value Selectable
+\value NotSelectable
+\value DragEnabled
+\value DragDisabled
+\value DropEnabled
+\value DropDisabled
+\value Expandable
+\value NotExpandable
+\value Checked
+\value NotChecked
+*/
+/*!
+Constructs an empty iterator.
+*/
+Q3ListViewItemIterator::Q3ListViewItemIterator()
+:  curr(0), listView(0), flags(0)
+{
+}
+/*!
+Constructs an iterator for the Q3ListView that contains the \a
+item. The current iterator item is set to point to the \a item.
+*/
+Q3ListViewItemIterator::Q3ListViewItemIterator(Q3ListViewItem *item)
+:  curr(item), listView(0), flags(0)
+{
+if (item) {
+item->enforceSortOrderBackToRoot();
+listView = item->listView();
+}
+if (listView)
+listView->d->iterators.append(this);
+}
+/*!
+Constructs an iterator for the Q3ListView that contains the \a item
+using the flags \a iteratorFlags. The current iterator item is set
+to point to \a item or the next matching item if \a item doesn't
+match the flags.
+\sa Q3ListViewItemIterator::IteratorFlag
+*/
+Q3ListViewItemIterator::Q3ListViewItemIterator(Q3ListViewItem *item, int iteratorFlags)
+:  curr(item), listView(0), flags(iteratorFlags)
+{
+// go to next matching item if the current don't match
+if (curr && !matchesFlags(curr))
+++(*this);
+if (curr) {
+curr->enforceSortOrderBackToRoot();
+listView = curr->listView();
+}
+if (listView)
+listView->d->iterators.append(this);
+}
+/*!
+Constructs an iterator for the same Q3ListView as \a it. The
+current iterator item is set to point on the current item of \a
+it.
+*/
+Q3ListViewItemIterator::Q3ListViewItemIterator(const Q3ListViewItemIterator& it)
+: curr(it.curr), listView(it.listView), flags(it.flags)
+{
+if (listView)
+listView->d->iterators.append(this);
+}
+/*!
+Constructs an iterator for the Q3ListView \a lv. The current
+iterator item is set to point on the first child (Q3ListViewItem)
+of \a lv.
+*/
+Q3ListViewItemIterator::Q3ListViewItemIterator(Q3ListView *lv)
+: curr(lv->firstChild()), listView(lv), flags(0)
+{
+if (listView)
+listView->d->iterators.append(this);
+}
+/*!
+Constructs an iterator for the Q3ListView \a lv with the flags \a
+iteratorFlags. The current iterator item is set to point on the
+first child (Q3ListViewItem) of \a lv that matches the flags.
+\sa Q3ListViewItemIterator::IteratorFlag
+*/
+Q3ListViewItemIterator::Q3ListViewItemIterator(Q3ListView *lv, int iteratorFlags)
+: curr (lv->firstChild()), listView(lv), flags(iteratorFlags)
+{
+if (listView)
+listView->d->iterators.append(this);
+if (!matchesFlags(curr))
+++(*this);
+}
+/*!
+Assignment. Makes a copy of \a it and returns a reference to its
+iterator.
+*/
+Q3ListViewItemIterator &Q3ListViewItemIterator::operator=(const Q3ListViewItemIterator &it)
+{
+if (listView)
+listView->d->iterators.removeAll(this);
+listView = it.listView;
+curr = it.curr;
+flags = it.flags;
+if (listView)
+listView->d->iterators.append(this);
+// go to next matching item if the current don't match
+if (curr && !matchesFlags(curr))
+++(*this);
+return *this;
+}
+/*!
+Destroys the iterator.
+*/
+Q3ListViewItemIterator::~Q3ListViewItemIterator()
+{
+if (listView)
+listView->d->iterators.removeAll(this);
+}
+/*!
+Prefix ++. Makes the next item the new current item and returns
+it. Returns 0 if the current item is the last item or the
+Q3ListView is 0.
+*/
+Q3ListViewItemIterator &Q3ListViewItemIterator::operator++()
+{
+if (!curr)
+return *this;
+Q3ListViewItem *item = curr->firstChild();
+if (!item) {
+while ((item = curr->nextSibling()) == 0 ) {
+curr = curr->parent();
+if (curr == 0)
+break;
+}
+}
+curr = item;
+// if the next one doesn't match the flags we try one more ahead
+if (curr && !matchesFlags(curr))
+++(*this);
+return *this;
+}
+/*!
+\overload
+Postfix ++. Makes the next item the new current item and returns
+the item that \e was the current item.
+*/
+const Q3ListViewItemIterator Q3ListViewItemIterator::operator++(int)
+{
+Q3ListViewItemIterator oldValue = *this;
+++(*this);
+return oldValue;
+}
+/*!
+Sets the current item to the item \a j positions after the current
+item. If that item is beyond the last item, the current item is
+set to 0. Returns the current item.
+*/
+Q3ListViewItemIterator &Q3ListViewItemIterator::operator+=(int j)
+{
+while (curr && j--)
+++(*this);
+return *this;
+}
+/*!
+Prefix --. Makes the previous item the new current item and
+returns it. Returns 0 if the current item is the first item or the
+Q3ListView is 0.
+*/
+Q3ListViewItemIterator &Q3ListViewItemIterator::operator--()
+{
+if (!curr)
+return *this;
+if (!curr->parent()) {
+// we are in the first depth
+if (curr->listView()) {
+if (curr->listView()->firstChild() != curr) {
+// go the previous sibling
+Q3ListViewItem *i = curr->listView()->firstChild();
+while (i && i->siblingItem != curr)
+i = i->siblingItem;
+curr = i;
+if (i && i->firstChild()) {
+// go to the last child of this item
+Q3ListViewItemIterator it(curr->firstChild());
+for (; it.current() && it.current()->parent(); ++it)
+curr = it.current();
+}
+if (curr && !matchesFlags(curr))
+--(*this);
+return *this;
+} else {
+//we are already the first child of the list view, so it's over
+curr = 0;
+return *this;
+}
+} else
+return *this;
+} else {
+Q3ListViewItem *parent = curr->parent();
+if (curr != parent->firstChild()) {
+// go to the previous sibling
+Q3ListViewItem *i = parent->firstChild();
+while (i && i->siblingItem != curr)
+i = i->siblingItem;
+curr = i;
+if (i && i->firstChild()) {
+// go to the last child of this item
+Q3ListViewItemIterator it(curr->firstChild());
+for (; it.current() && it.current()->parent() != parent; ++it)
+curr = it.current();
+}
+if (curr && !matchesFlags(curr))
+--(*this);
+return *this;
+} else {
+// make our parent the current item
+curr = parent;
+if (curr && !matchesFlags(curr))
+--(*this);
+return *this;
+}
+}
+}
+/*!
+\overload
+Postfix --. Makes the previous item the new current item and
+returns the item that \e was the current item.
+*/
+const Q3ListViewItemIterator Q3ListViewItemIterator::operator--(int)
+{
+Q3ListViewItemIterator oldValue = *this;
+--(*this);
+return oldValue;
+}
+/*!
+Sets the current item to the item \a j positions before the
+current item. If that item is before the first item, the current
+item is set to 0. Returns the current item.
+*/
+Q3ListViewItemIterator &Q3ListViewItemIterator::operator-=(int j)
+{
+while (curr && j--)
+--(*this);
+return *this;
+}
+/*!
+Dereference operator. Returns a reference to the current item. The
+same as current().
+*/
+Q3ListViewItem* Q3ListViewItemIterator::operator*()
+{
+if (curr != 0 && !matchesFlags(curr))
+qWarning("Q3ListViewItemIterator::operator*() curr out of sync");
+return curr;
+}
+/*!
+Returns iterator's current item.
+*/
+Q3ListViewItem *Q3ListViewItemIterator::current() const
+{
+if (curr != 0 && !matchesFlags(curr))
+qWarning("Q3ListViewItemIterator::current() curr out of sync");
+return curr;
+}
+/*
+This function is called to notify the iterator that the current
+item has been deleted, and sets the current item point to another
+(valid) item or 0.
+*/
+void Q3ListViewItemIterator::currentRemoved()
+{
+if (!curr) return;
+if (curr->parent())
+curr = curr->parent();
+else if (curr->nextSibling())
+curr = curr->nextSibling();
+else if (listView && listView->firstChild() &&
+listView->firstChild() != curr)
+curr = listView->firstChild();
+else
+curr = 0;
+}
+/*
+returns true if the item \a item matches all of the flags set for the iterator
+*/
+bool Q3ListViewItemIterator::matchesFlags(const Q3ListViewItem *item) const
+{
+if (!item)
+return false;
+if (flags == 0)
+return true;
+if (flags & Visible && !item->isVisible())
+return false;
+if (flags & Invisible && item->isVisible())
+return false;
+if (flags & Selected && !item->isSelected())
+return false;
+if (flags & Unselected && item->isSelected())
+return false;
+if (flags & Selectable && !item->isSelectable())
+return false;
+if (flags & NotSelectable && item->isSelectable())
+return false;
+if (flags & DragEnabled && !item->dragEnabled())
+return false;
+if (flags & DragDisabled && item->dragEnabled())
+return false;
+if (flags & DropEnabled && !item->dropEnabled())
+return false;
+if (flags & DropDisabled && item->dropEnabled())
+return false;
+if (flags & Expandable && !item->isExpandable())
+return false;
+if (flags & NotExpandable && item->isExpandable())
+return false;
+if (flags & Checked && !isChecked(item))
+return false;
+if (flags & NotChecked && isChecked(item))
+return false;
+return true;
+}
+/*
+we want the iterator to check Q3CheckListItems as well, so we provide this convenience function
+that checks if the rtti() is 1 which means Q3CheckListItem and if isOn is true, returns false otherwise.
+*/
+bool Q3ListViewItemIterator::isChecked(const Q3ListViewItem *item) const
+{
+if (item->rtti() == 1)
+return ((const Q3CheckListItem*)item)->isOn();
+else return false;
+}
+void Q3ListView::handleItemChange(Q3ListViewItem *old, bool shift, bool control)
+{
+if (d->selectionMode == Single) {
+// nothing
+} else if (d->selectionMode == Extended) {
+if (shift) {
+selectRange(d->selectAnchor ? d->selectAnchor : old,
+d->focusItem, false, true, (d->selectAnchor && !control) ? true : false);
+} else if (!control) {
+bool block = signalsBlocked();
+blockSignals(true);
+selectAll(false);
+blockSignals(block);
+setSelected(d->focusItem, true);
+}
+} else if (d->selectionMode == Multi) {
+if (shift)
+selectRange(old, d->focusItem, true, false);
+}
+}
+void Q3ListView::startRename()
+{
+if (!currentItem())
+return;
+currentItem()->startRename(d->pressedColumn);
+d->buttonDown = false;
+}
+/* unselects items from to, including children, returns true if any items were unselected */
+bool Q3ListView::clearRange(Q3ListViewItem *from, Q3ListViewItem *to, bool includeFirst)
+{
+if (!from || !to)
+return false;
+// Swap
+if (from->itemPos() > to->itemPos()) {
+Q3ListViewItem *temp = from;
+from = to;
+to = temp;
+}
+// Start on second?
+if (!includeFirst) {
+Q3ListViewItem *below = (from == to) ? from : from->itemBelow();
+if (below)
+from = below;
+}
+// Clear items <from, to>
+bool changed = false;
+Q3ListViewItemIterator it(from);
+while (it.current()) {
+if (it.current()->isSelected()) {
+it.current()->setSelected(false);
+changed = true;
+}
+if (it.current() == to)
+break;
+++it;
+}
+// NOTE! This function does _not_ emit
+// any signals about selection changed
+return changed;
+}
+void Q3ListView::selectRange(Q3ListViewItem *from, Q3ListViewItem *to, bool invert, bool includeFirst, bool clearSel)
+{
+if (!from || !to)
+return;
+if (from == to && !includeFirst)
+return;
+bool swap = false;
+if (to == from->itemAbove())
+swap = true;
+if (!swap && from != to && from != to->itemAbove()) {
+Q3ListViewItemIterator it(from);
+bool found = false;
+for (; it.current(); ++it) {
+if (it.current() == to) {
+found = true;
+break;
+}
+}
+if (!found)
+swap = true;
+}
+if (swap) {
+Q3ListViewItem *i = from;
+from = to;
+to = i;
+if (!includeFirst)
+to = to->itemAbove();
+} else {
+if (!includeFirst)
+from = from->itemBelow();
+}
+bool changed = false;
+if (clearSel) {
+Q3ListViewItemIterator it(firstChild());
+for (; it.current(); ++it) {
+if (it.current()->selected) {
+it.current()->setSelected(false);
+changed = true;
+}
+}
+it = Q3ListViewItemIterator(to);
+for (; it.current(); ++it) {
+if (it.current()->selected) {
+it.current()->setSelected(false);
+changed = true;
+}
+}
+}
+for (Q3ListViewItem *i = from; i; i = i->itemBelow()) {
+if (!invert) {
+if (!i->selected && i->isSelectable()) {
+i->setSelected(true);
+changed = true;
+}
+} else {
+bool sel = !i->selected;
+if (((bool)i->selected != sel && sel && i->isSelectable()) || !sel) {
+i->setSelected(sel);
+changed = true;
+}
+}
+if (i == to)
+break;
+}
+if (changed) {
+triggerUpdate();
+emit selectionChanged();
+}
+}
+/* clears selection from anchor to old, selects from anchor to new, does not emit selectionChanged on change */
+bool Q3ListView::selectRange(Q3ListViewItem *newItem, Q3ListViewItem *oldItem, Q3ListViewItem *anchorItem)
+{
+if (!newItem || !oldItem || !anchorItem)
+return false;
+int  anchorPos = anchorItem ? anchorItem->itemPos() : 0,
+oldPos    = oldItem ? oldItem->itemPos() : 0,
+newPos    = newItem->itemPos();
+Q3ListViewItem *top=0, *bottom=0;
+if (anchorPos > newPos) {
+top = newItem;
+bottom = anchorItem;
+} else {
+top = anchorItem;
+bottom = newItem;
+}
+// removes the subControls of the old selection that will no longer be selected
+bool changed = false;
+int topPos    = top ? top->itemPos() : 0,
+bottomPos = bottom ? bottom->itemPos() : 0;
+if (!(oldPos > topPos && oldPos < bottomPos)) {
+if (oldPos < topPos)
+changed = clearRange(oldItem, top);
+else
+changed = clearRange(bottom, oldItem);
+}
+// selects the new (not already selected) items
+Q3ListViewItemIterator lit(top);
+for (; lit.current(); ++lit) {
+if ((bool)lit.current()->selected != d->select) {
+lit.current()->setSelected(d->select);
+changed = true;
+}
+// Include bottom, then break
+if (lit.current() == bottom)
+break;
+}
+return changed;
+}
+/*!
+Finds the first list view item in column \a column, that matches
+\a text and returns the item, or returns 0 of no such item could
+be found. Pass OR-ed together \l ComparisonFlags values
+in the \a compare flag, to control how the matching is performed.
+The default comparison mode is case-sensitive, exact match.
+*/
+Q3ListViewItem *Q3ListView::findItem(const QString& text, int column,
+ComparisonFlags compare) const
+{
+if (text.isEmpty() && !(compare & ExactMatch))
+return 0;
+if (compare == Qt::CaseSensitive || compare == 0)
+compare |= ExactMatch;
+QString itmtxt;
+QString comtxt = text;
+if (!(compare & Qt::CaseSensitive))
+comtxt = comtxt.toLower();
+Q3ListViewItemIterator it(d->focusItem ? d->focusItem : firstChild());
+Q3ListViewItem *sentinel = 0;
+Q3ListViewItem *item;
+Q3ListViewItem *beginsWithItem = 0;
+Q3ListViewItem *endsWithItem = 0;
+Q3ListViewItem *containsItem = 0;
+for (int pass = 0; pass < 2; pass++) {
+while ((item = it.current()) != sentinel) {
+itmtxt = item->text(column);
+if (!(compare & CaseSensitive))
+itmtxt = itmtxt.toLower();
+if ((compare & ExactMatch)==ExactMatch && itmtxt == comtxt)
+return item;
+if (compare & BeginsWith && !beginsWithItem && itmtxt.startsWith(comtxt))
+beginsWithItem = containsItem = item;
+if (compare & EndsWith && !endsWithItem && itmtxt.endsWith(comtxt))
+endsWithItem = containsItem = item;
+if ((compare & ExactMatch)==0 && !containsItem && itmtxt.contains(comtxt))
+containsItem = item;
+++it;
+}
+it = Q3ListViewItemIterator(firstChild());
+sentinel = d->focusItem ? d->focusItem : firstChild();
+}
+// Obey the priorities
+if (beginsWithItem)
+return beginsWithItem;
+else if (endsWithItem)
+return endsWithItem;
+else if (containsItem)
+return containsItem;
+return 0;
+}
+/*!
+Hides the column specified at \a column. This is a convenience
+function that calls setColumnWidth(column, 0).
+Note: The user may still be able to resize the hidden column using
+the header handles. To prevent this, call setResizeEnabled(false,
+\a column) on the list views header.
+\sa setColumnWidth()
+*/
+void Q3ListView::hideColumn(int column)
+{
+setColumnWidth(column, 0);
+}
+/*! Adjusts the column \a col to its preferred width */
+void Q3ListView::adjustColumn(int col)
+{
+if (col < 0 || col > (int)d->column.count() - 1 || d->h->isStretchEnabled(col))
+return;
+int oldw = d->h->sectionSize(col);
+int w = d->h->sectionSizeHint(col, fontMetrics()).width();
+if (d->h->iconSet(col))
+w += d->h->iconSet(col)->pixmap().width();
+w = qMax(w, 20);
+QFontMetrics fm(fontMetrics());
+Q3ListViewItem* item = firstChild();
+int rootDepth = rootIsDecorated() ? treeStepSize() : 0;
+while (item) {
+int iw = item->width(fm, this, col);
+if (0 == col)
+iw += itemMargin() + rootDepth + item->depth()*treeStepSize() - 1;
+w = qMax(w, iw);
+item = item->itemBelow();
+}
+w = qMax(w, QApplication::globalStrut().width());
+d->h->adjustHeaderSize(oldw - w);
+if (oldw != w) {
+d->fullRepaintOnComlumnChange = true;
+d->h->resizeSection(col, w);
+emit d->h->sizeChange(col, oldw, w);
+}
+}
+/*!
+\enum Q3ListView::StringComparisonMode
+This enum type is used to set the string comparison mode when
+searching for an item. We'll refer to the string being searched
+as the 'target' string.
+\value CaseSensitive The strings must match case sensitively.
+\value ExactMatch The target and search strings must match exactly.
+\value BeginsWith The target string begins with the search string.
+\value EndsWith The target string ends with the search string.
+\value Contains The target string contains the search string.
+If you OR these flags together (excluding \c CaseSensitive), the
+search criteria be applied in the following order: \c ExactMatch,
+\c BeginsWith, \c EndsWith, \c Contains.
+Matching is case-insensitive unless \c CaseSensitive is set. \c
+CaseSensitive can be OR-ed with any combination of the other
+flags.
+\sa ComparisonFlags
+*/
+/*!
+\typedef Q3ListView::ComparisonFlags
+This typedef is used in Q3ListView's API for values that are OR'd
+combinations of \l StringComparisonMode values.
+\sa StringComparisonMode
+*/
+QT_END_NAMESPACE
+#endif // QT_NO_LISTVIEW

changeset 0	1918ee327afb
child 4	3b1da2848fc7