MCL/sf/mw/qt: comparison src/qt3support/itemviews/q3iconview.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 "qglobal.h"
+#if defined(Q_CC_BOR)
+// needed for qsort() because of a std namespace problem on Borland
+#include "qplatformdefs.h"
+#endif
+#include "q3iconview.h"
+#ifndef QT_NO_ICONVIEW
+#include "private/q3richtext_p.h"
+#include "q3textedit.h"
+#include "qapplication.h"
+#include "qbitmap.h"
+#include "qbrush.h"
+#include "q3cleanuphandler.h"
+#include "qcursor.h"
+#include "qevent.h"
+#include "qfontmetrics.h"
+#include "qhash.h"
+#include "qimage.h"
+#include "qmime.h"
+#include "qpainter.h"
+#include "qpalette.h"
+#include "qpen.h"
+#include "qpixmapcache.h"
+#include "qstringlist.h"
+#include "qstyle.h"
+#include "qstyleoption.h"
+#include "qtimer.h"
+#include "qtooltip.h"
+#include "q3strlist.h"
+#include <limits.h>
+#include <stdlib.h>
+QT_BEGIN_NAMESPACE
+#define RECT_EXTENSION 300
+static const char * const unknown_xpm[] = {
+"32 32 11 1",
+"c c #ffffff",
+"g c #c0c0c0",
+"a c #c0ffc0",
+"h c #a0a0a4",
+"d c #585858",
+"f c #303030",
+"i c #400000",
+"b c #00c000",
+"e c #000000",
+"# c #000000",
+". c None",
+"...###..........................",
+"...#aa##........................",
+".###baaa##......................",
+".#cde#baaa##....................",
+".#cccdeebaaa##..##f.............",
+".#cccccdeebaaa##aaa##...........",
+".#cccccccdeebaaaaaaaa##.........",
+".#cccccccccdeebaaaaaaa#.........",
+".#cccccgcgghhebbbbaaaaa#........",
+".#ccccccgcgggdebbbbbbaa#........",
+".#cccgcgcgcgghdeebiebbba#.......",
+".#ccccgcggggggghdeddeeba#.......",
+".#cgcgcgcggggggggghghdebb#......",
+".#ccgcggggggggghghghghd#b#......",
+".#cgcgcggggggggghghghhd#b#......",
+".#gcggggggggghghghhhhhd#b#......",
+".#cgcggggggggghghghhhhd#b#......",
+".#ggggggggghghghhhhhhhdib#......",
+".#gggggggggghghghhhhhhd#b#......",
+".#hhggggghghghhhhhhhhhd#b#......",
+".#ddhhgggghghghhhhhhhhd#b#......",
+"..##ddhhghghhhhhhhhhhhdeb#......",
+"....##ddhhhghhhhhhhhhhd#b#......",
+"......##ddhhhhhhhhhhhhd#b#......",
+"........##ddhhhhhhhhhhd#b#......",
+"..........##ddhhhhhhhhd#b#......",
+"............##ddhhhhhhd#b###....",
+"..............##ddhhhhd#b#####..",
+"................##ddhhd#b######.",
+"..................##dddeb#####..",
+"....................##d#b###....",
+"......................####......"};
+static QPixmap *unknown_icon = 0;
+static QPixmap *qiv_buffer_pixmap = 0;
+#if !defined(Q_WS_X11)
+static QPixmap *qiv_selection = 0;
+#endif
+static bool optimize_layout = false;
+static Q3CleanupHandler<QPixmap> qiv_cleanup_pixmap;
+static QPixmap *get_qiv_buffer_pixmap(const QSize &s)
+{
+if (!qiv_buffer_pixmap) {
+qiv_buffer_pixmap = new QPixmap(s);
+qiv_cleanup_pixmap.add(&qiv_buffer_pixmap);
+return qiv_buffer_pixmap;
+}
+qiv_buffer_pixmap->resize(s);
+return qiv_buffer_pixmap;
+}
+#ifndef QT_NO_DRAGANDDROP
+class Q_COMPAT_EXPORT Q3IconDragData
+{
+public:
+Q3IconDragData();
+Q3IconDragData(const QRect &ir, const QRect &tr);
+QRect pixmapRect() const;
+QRect textRect() const;
+void setPixmapRect(const QRect &r);
+void setTextRect(const QRect &r);
+QRect iconRect_, textRect_;
+QString key_;
+bool operator==(const Q3IconDragData &i) const;
+};
+class Q_COMPAT_EXPORT Q3IconDragDataItem
+{
+public:
+Q3IconDragDataItem() {}
+Q3IconDragDataItem(const Q3IconDragItem &i1, const Q3IconDragData &i2) : data(i1), item(i2) {}
+Q3IconDragItem data;
+Q3IconDragData item;
+bool operator== (const Q3IconDragDataItem&) const;
+};
+class Q3IconDragPrivate
+{
+public:
+QLinkedList<Q3IconDragDataItem> items;
+static bool decode(QMimeSource* e, QLinkedList<Q3IconDragDataItem> &lst);
+};
+#endif
+class Q3IconViewPrivate
+{
+public:
+Q3IconViewItem *firstItem, *lastItem;
+uint count;
+Q3IconView::SelectionMode selectionMode;
+Q3IconViewItem *currentItem, *tmpCurrentItem, *highlightedItem,
+*startDragItem, *pressedItem, *selectAnchor, *renamingItem;
+QRect *rubber;
+QTimer *scrollTimer, *adjustTimer, *updateTimer, *inputTimer,
+*fullRedrawTimer;
+int rastX, rastY, spacing;
+int dragItems;
+QPoint oldDragPos;
+Q3IconView::Arrangement arrangement;
+Q3IconView::ResizeMode resizeMode;
+QSize oldSize;
+#ifndef QT_NO_DRAGANDDROP
+QLinkedList<Q3IconDragDataItem> iconDragData;
+#endif
+int numDragItems, cachedW, cachedH;
+int maxItemWidth, maxItemTextLength;
+QPoint dragStart;
+QString currInputString;
+Q3IconView::ItemTextPos itemTextPos;
+#ifndef QT_NO_CURSOR
+QCursor oldCursor;
+#endif
+int cachedContentsX, cachedContentsY;
+QBrush itemTextBrush;
+QRegion clipRegion;
+QPoint dragStartPos;
+QFontMetrics *fm;
+int minLeftBearing, minRightBearing;
+uint mousePressed : 1;
+uint cleared : 1;
+uint dropped : 1;
+uint clearing : 1;
+uint oldDragAcceptAction : 1;
+uint isIconDrag : 1;
+uint drawDragShapes : 1;
+uint dirty : 1;
+uint rearrangeEnabled : 1;
+uint reorderItemsWhenInsert : 1;
+uint drawAllBack : 1;
+uint resortItemsWhenInsert : 1;
+uint sortDirection : 1;
+uint wordWrapIconText : 1;
+uint containerUpdateLocked : 1;
+uint firstSizeHint : 1;
+uint showTips : 1;
+uint pressedSelected : 1;
+uint dragging : 1;
+uint drawActiveSelection : 1;
+uint inMenuMode : 1;
+QPoint dragPos;
+QPixmapCache maskCache;
+QHash<Q3IconViewItem *, Q3IconViewItem *> selectedItems;
+struct ItemContainer {
+ItemContainer(ItemContainer *pr, ItemContainer *nx, const QRect &r)
+: p(pr), n(nx), rect(r)
+{
+if (p)
+p->n = this;
+if (n)
+n->p = this;
+}
+ItemContainer *p, *n;
+QRect rect;
+QList<Q3IconViewItem*> items;
+} *firstContainer, *lastContainer;
+struct SortableItem {
+Q3IconViewItem *item;
+};
+public:
+/* finds the containers that intersect with \a searchRect in the direction \a dir relative to \a relativeTo */
+QList<ItemContainer* >* findContainers(
+Q3IconView:: Direction dir,
+const QPoint &relativeTo,
+const QRect &searchRect) const;
+//    friend int cmpIconViewItems(const void *n1, const void *n2);
+};
+QList<Q3IconViewPrivate::ItemContainer *>* Q3IconViewPrivate::findContainers(
+Q3IconView:: Direction dir,
+const QPoint &relativeTo,
+const QRect &searchRect) const
+{
+QList<Q3IconViewPrivate::ItemContainer *>* list =
+new QList<Q3IconViewPrivate::ItemContainer*>();
+if (arrangement == Q3IconView::LeftToRight) {
+if (dir == Q3IconView::DirLeft || dir == Q3IconView::DirRight) {
+ItemContainer *c = firstContainer;
+for (; c; c = c->n)
+if (c->rect.intersects(searchRect))
+list->append(c);
+} else {
+if (dir == Q3IconView::DirDown) {
+ItemContainer *c = firstContainer;
+for (; c; c = c->n)
+if (c->rect.intersects(searchRect) &&
+c->rect.bottom() >= relativeTo.y())
+list->append(c);
+} else {
+ItemContainer *c = lastContainer;
+for (; c; c = c->p)
+if (c->rect.intersects(searchRect) &&
+c->rect.top() <= relativeTo.y())
+list->append(c);
+}
+}
+} else {
+if (dir == Q3IconView::DirUp || dir == Q3IconView::DirDown) {
+ItemContainer *c = firstContainer;
+for (; c; c = c->n)
+if (c->rect.intersects(searchRect))
+list->append(c);
+} else {
+if (dir == Q3IconView::DirRight) {
+ItemContainer *c = firstContainer;
+for (; c; c = c->n)
+if (c->rect.intersects(searchRect) &&
+c->rect.right() >= relativeTo.x())
+list->append(c);
+} else {
+ItemContainer *c = lastContainer;
+for (; c; c = c->p)
+if (c->rect.intersects(searchRect) &&
+c->rect.left() <= relativeTo.x())
+list->append(c);
+}
+}
+}
+return list;
+}
+#if defined(Q_C_CALLBACKS)
+extern "C" {
+#endif
+#ifdef Q_OS_WINCE
+static int _cdecl cmpIconViewItems(const void *n1, const void *n2)
+#else
+static int cmpIconViewItems(const void *n1, const void *n2)
+#endif
+{
+if (!n1 || !n2)
+return 0;
+Q3IconViewPrivate::SortableItem *i1 = (Q3IconViewPrivate::SortableItem *)n1;
+Q3IconViewPrivate::SortableItem *i2 = (Q3IconViewPrivate::SortableItem *)n2;
+return i1->item->compare(i2->item);
+}
+#if defined(Q_C_CALLBACKS)
+}
+#endif
+class Q3IconViewItemPrivate
+{
+public:
+Q3IconViewPrivate::ItemContainer *container1, *container2;
+};
+#ifndef QT_NO_TEXTEDIT
+class Q3IconViewItemLineEdit : public Q3TextEdit
+{
+friend class Q3IconViewItem;
+public:
+Q3IconViewItemLineEdit(const QString &text, QWidget *parent, Q3IconViewItem *theItem, const char* name=0);
+protected:
+void keyPressEvent(QKeyEvent *e);
+void focusOutEvent(QFocusEvent *e);
+protected:
+Q3IconViewItem *item;
+QString startText;
+private:
+Q_DISABLE_COPY(Q3IconViewItemLineEdit)
+};
+Q3IconViewItemLineEdit::Q3IconViewItemLineEdit(const QString &text, QWidget *parent,
+Q3IconViewItem *theItem, const char *name)
+: Q3TextEdit(parent, name), item(theItem), startText(text)
+{
+setFrameStyle(QFrame::Plain | QFrame::Box);
+setLineWidth(1);
+setHScrollBarMode(AlwaysOff);
+setVScrollBarMode(AlwaysOff);
+setWordWrap(WidgetWidth);
+setWrapColumnOrWidth(item->iconView()->maxItemWidth() -
+(item->iconView()->itemTextPos() == Q3IconView::Bottom ?
+0 : item->pixmapRect().width()));
+document()->formatter()->setAllowBreakInWords(true);
+resize(200, 200); // ### some size, there should be a forceReformat()
+setTextFormat(Qt::PlainText);
+setText(text);
+setAlignment(Qt::AlignCenter);
+resize(wrapColumnOrWidth() + 2, heightForWidth(wrapColumnOrWidth()) + 2);
+}
+void Q3IconViewItemLineEdit::keyPressEvent(QKeyEvent *e)
+{
+if (e->key()  == Qt::Key_Escape) {
+item->Q3IconViewItem::setText(startText);
+item->cancelRenameItem();
+} else if (e->key() == Qt::Key_Enter ||
+e->key() == Qt::Key_Return) {
+item->renameItem();
+} else {
+Q3TextEdit::keyPressEvent(e);
+sync();
+resize(width(), document()->height() + 2);
+}
+}
+void Q3IconViewItemLineEdit::focusOutEvent(QFocusEvent *e)
+{
+Q_UNUSED(e) // I need this to get rid of a Borland warning
+if (e->reason() != Qt::PopupFocusReason)
+item->cancelRenameItem();
+}
+#endif
+#ifndef QT_NO_DRAGANDDROP
+/*!
+\class Q3IconDragItem
+\brief The Q3IconDragItem class encapsulates a drag item.
+\compat
+The Q3IconDrag class uses a list of Q3IconDragItems to support drag
+and drop operations.
+In practice a Q3IconDragItem object (or an object of a class derived
+from Q3IconDragItem) is created for each icon view item which is
+dragged. Each of these Q3IconDragItems is stored in a Q3IconDrag
+object.
+See Q3IconView::dragObject() for more information.
+*/
+/*!
+Constructs a Q3IconDragItem with no data.
+*/
+Q3IconDragItem::Q3IconDragItem()
+{
+ba = "no data";
+}
+/*!
+Destructor.
+*/
+Q3IconDragItem::~Q3IconDragItem()
+{
+}
+/*!
+Returns the data contained in the Q3IconDragItem.
+*/
+QByteArray Q3IconDragItem::data() const
+{
+return ba;
+}
+/*!
+Sets the data for the Q3IconDragItem to the data stored in the
+QByteArray \a d.
+*/
+void Q3IconDragItem::setData(const QByteArray &d)
+{
+ba = d;
+}
+/*!
+\internal
+*/
+bool Q3IconDragItem::operator==(const Q3IconDragItem &i) const
+{
+return ba == i.ba;
+}
+/*!
+\reimp
+*/
+bool Q3IconDragDataItem::operator==(const Q3IconDragDataItem &i) const
+{
+return (i.item == item &&
+i.data == data);
+}
+/*!
+\reimp
+*/
+bool Q3IconDragData::operator==(const Q3IconDragData &i) const
+{
+return key_ == i.key_;
+}
+/*!
+\class Q3IconDrag
+\brief The Q3IconDrag class supports drag and drop operations
+within a Q3IconView.
+\compat
+A Q3IconDrag object is used to maintain information about the
+positions of dragged items and the data associated with them.
+Q3IconViews are able to use this information to paint the dragged
+items in the correct positions. Internally, Q3IconDrag stores the
+data associated with drag items in Q3IconDragItem objects.
+If you want to use the extended drag and drop functionality of
+Q3IconView, create a Q3IconDrag object in a reimplementation of
+Q3IconView::dragObject(). Then create a Q3IconDragItem for each item
+which should be dragged, set the data it represents with
+Q3IconDragItem::setData(), and add each Q3IconDragItem to the drag
+object using append().
+The data in Q3IconDragItems is stored in a QByteArray and is
+mime-typed (see QMimeSource and the
+\link http://qt.nokia.com/doc/dnd.html Drag and Drop\endlink
+overview). If you want to use your own mime-types derive a class
+from Q3IconDrag and reimplement format(), encodedData() and
+canDecode().
+The fileiconview example program demonstrates the use of the
+Q3IconDrag class including subclassing and reimplementing
+dragObject(), format(), encodedData() and canDecode().
+\sa QMimeSource::format()
+*/
+/*!
+Constructs a drag object called \a name, which is a child of \a
+dragSource.
+Note that the drag object will be deleted when \a dragSource is deleted.
+*/
+Q3IconDrag::Q3IconDrag(QWidget * dragSource, const char* name)
+: Q3DragObject(dragSource, name)
+{
+d = new Q3IconDragPrivate;
+}
+/*!
+Destructor.
+*/
+Q3IconDrag::~Q3IconDrag()
+{
+delete d;
+}
+/*!
+Append the Q3IconDragItem, \a i, to the Q3IconDrag object's list of
+items. You must also supply the geometry of the pixmap, \a pr, and
+the textual caption, \a tr.
+\sa Q3IconDragItem
+*/
+void Q3IconDrag::append(const Q3IconDragItem &i, const QRect &pr, const QRect &tr)
+{
+d->items.append(Q3IconDragDataItem(i, Q3IconDragData(pr, tr)));
+}
+/*!
+\reimp
+*/
+const char* Q3IconDrag::format(int i) const
+{
+if (i == 0)
+return "application/x-qiconlist";
+return 0;
+}
+/*!
+Returns the encoded data of the drag object if \a mime is
+application/x-qiconlist.
+*/
+QByteArray Q3IconDrag::encodedData(const char* mime) const
+{
+if (d->items.size() <= 0 || QString::fromLatin1(mime) !=
+QString::fromLatin1("application/x-qiconlist"))
+return QByteArray();
+QLinkedList<Q3IconDragDataItem>::ConstIterator it = d->items.begin();
+QString s;
+for (; it != d->items.end(); ++it) {
+QString k(QLatin1String("%1$@@$%2$@@$%3$@@$%4$@@$%5$@@$%6$@@$%7$@@$%8$@@$"));
+k = k.arg((*it).item.pixmapRect().x()).arg(
+(*it).item.pixmapRect().y()).arg((*it).item.pixmapRect().width()).
+arg((*it).item.pixmapRect().height()).arg(
+(*it).item.textRect().x()).arg((*it).item.textRect().y()).
+arg((*it).item.textRect().width()).arg(
+(*it).item.textRect().height());
+k += QString::fromLatin1((*it).data.data()) + QLatin1String("$@@$");
+s += k;
+}
+QByteArray a;
+a.resize(s.length() + 1);
+memcpy(a.data(), s.latin1(), a.size());
+return a;
+}
+/*!
+Returns true if \a e can be decoded by the Q3IconDrag, otherwise
+return false.
+*/
+bool Q3IconDrag::canDecode(QMimeSource* e)
+{
+if (e->provides("application/x-qiconlist"))
+return true;
+return false;
+}
+/*!
+Decodes the data which is stored (encoded) in \a e and, if
+successful, fills the \a list of icon drag items with the decoded
+data. Returns true if there was some data, false otherwise.
+*/
+bool Q3IconDragPrivate::decode(QMimeSource* e, QLinkedList<Q3IconDragDataItem> &lst)
+{
+QByteArray ba = e->encodedData("application/x-qiconlist");
+if (ba.size()) {
+lst.clear();
+// #### unicode clean????
+QString s = QString::fromLatin1(ba);
+Q3IconDragDataItem item;
+QRect ir, tr;
+QStringList l = QStringList::split(QLatin1String("$@@$"), s);
+int i = 0;
+QStringList::Iterator it = l.begin();
+for (; it != l.end(); ++it) {
+if (i == 0) {
+ir.setX((*it).toInt());
+} else if (i == 1) {
+ir.setY((*it).toInt());
+} else if (i == 2) {
+ir.setWidth((*it).toInt());
+} else if (i == 3) {
+ir.setHeight((*it).toInt());
+} else if (i == 4) {
+tr.setX((*it).toInt());
+} else if (i == 5) {
+tr.setY((*it).toInt());
+} else if (i == 6) {
+tr.setWidth((*it).toInt());
+} else if (i == 7) {
+tr.setHeight((*it).toInt());
+} else if (i == 8) {
+QByteArray d;
+d.resize((*it).length());
+memcpy(d.data(), (*it).latin1(), (*it).length());
+item.item.setPixmapRect(ir);
+item.item.setTextRect(tr);
+item.data.setData(d);
+lst.append(item);
+}
+++i;
+if (i > 8)
+i = 0;
+}
+return true;
+}
+return false;
+}
+Q3IconDragData::Q3IconDragData()
+: iconRect_(), textRect_()
+{
+}
+Q3IconDragData::Q3IconDragData(const QRect &ir, const QRect &tr)
+: iconRect_(ir), textRect_(tr)
+{
+}
+QRect Q3IconDragData::textRect() const
+{
+return textRect_;
+}
+QRect Q3IconDragData::pixmapRect() const
+{
+return iconRect_;
+}
+void Q3IconDragData::setPixmapRect(const QRect &r)
+{
+iconRect_ = r;
+}
+void Q3IconDragData::setTextRect(const QRect &r)
+{
+textRect_ = r;
+}
+#endif
+/*!
+\class Q3IconViewItem
+\brief The Q3IconViewItem class provides a single item in a Q3IconView.
+\compat
+A Q3IconViewItem contains an icon, a string and optionally a sort
+key, and can display itself in a Q3IconView.
+The simplest way to create a Q3IconViewItem and insert it into a
+Q3IconView is to construct the item passing the constructor a
+pointer to the icon view, a string and an icon:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 0
+By default the text of an icon view item may not be edited by the
+user but calling setRenameEnabled(true) will allow the user to
+perform in-place editing of the item's text.
+When the icon view is deleted all items in it are deleted
+automatically.
+The Q3IconView::firstItem() and Q3IconViewItem::nextItem() functions
+provide a means of iterating over all the items in a Q3IconView:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 1
+The item's icon view is available from iconView(), and its
+position in the icon view from index().
+The item's selection status is available from isSelected() and is
+set and controlled by setSelected() and isSelectable().
+The text and icon can be set with setText() and setPixmap() and
+retrieved with text() and pixmap(). The item's sort key defaults
+to text() but may be set with setKey() and retrieved with key().
+The comparison function, compare() uses key().
+Items may be repositioned with move() and moveBy(). An item's
+geometry is available from rect(), x(), y(), width(), height(),
+size(), pos(), textRect() and pixmapRect(). You can also test
+against the position of a point with contains() and intersects().
+To remove an item from an icon view, just delete the item. The
+Q3IconViewItem destructor removes it cleanly from its icon view.
+Because the icon view is designed to use drag-and-drop, the icon
+view item also has functions for drag-and-drop which may be
+reimplemented.
+The class is designed to be very similar to Q3ListView and Q3ListBox
+in use, both via instantiation and subclassing.
+*/
+/*!
+Constructs a Q3IconViewItem and inserts it into icon view \a parent
+with no text and a default icon.
+*/
+Q3IconViewItem::Q3IconViewItem(Q3IconView *parent)
+: view(parent), itemText(), itemIcon(unknown_icon)
+{
+init();
+}
+/*!
+Constructs a Q3IconViewItem and inserts it into the icon view \a
+parent with no text and a default icon, after the icon view item
+\a after.
+*/
+Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after)
+: view(parent), itemText(), itemIcon(unknown_icon),
+prev(0), next(0)
+{
+init(after);
+}
+/*!
+Constructs an icon view item  and inserts it into the icon view \a
+parent using \a text as the text and a default icon.
+*/
+Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, const QString &text)
+: view(parent), itemText(text), itemIcon(unknown_icon)
+{
+init(0);
+}
+/*!
+Constructs an icon view item and inserts it into the icon view \a
+parent using \a text as the text and a default icon, after the
+icon view item \a after.
+*/
+Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after,
+const QString &text)
+: view(parent), itemText(text), itemIcon(unknown_icon)
+{
+init(after);
+}
+/*!
+Constructs an icon view item and inserts it into the icon view \a
+parent using \a text as the text and \a icon as the icon.
+*/
+Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, const QString &text,
+const QPixmap &icon)
+: view(parent),
+itemText(text), itemIcon(new QPixmap(icon))
+{
+init(0);
+}
+/*!
+Constructs an icon view item and inserts it into the icon view \a
+parent using \a text as the text and \a icon as the icon, after
+the icon view item \a after.
+*/
+Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after,
+const QString &text, const QPixmap &icon)
+: view(parent), itemText(text), itemIcon(new QPixmap(icon))
+{
+init(after);
+}
+/*!
+Constructs an icon view item and inserts it into the icon view \a
+parent using \a text as the text and \a picture as the icon.
+*/
+#ifndef QT_NO_PICTURE
+Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, const QString &text,
+const QPicture &picture)
+: view(parent), itemText(text), itemIcon(0)
+{
+init(0, new QPicture(picture));
+}
+/*!
+Constructs an icon view item and inserts it into the icon view \a
+parent using \a text as the text and \a picture as the icon, after
+the icon view item \a after.
+*/
+Q3IconViewItem::Q3IconViewItem(Q3IconView *parent, Q3IconViewItem *after,
+const QString &text, const QPicture &picture)
+: view(parent), itemText(text), itemIcon(0)
+{
+init(after, new QPicture(picture));
+}
+#endif
+/*!
+This private function initializes the icon view item and inserts it
+into the icon view.
+*/
+void Q3IconViewItem::init(Q3IconViewItem *after
+#ifndef QT_NO_PICTURE
+, QPicture *pic
+#endif
+)
+{
+d = new Q3IconViewItemPrivate;
+d->container1 = 0;
+d->container2 = 0;
+prev = next = 0;
+allow_rename = false;
+allow_drag = true;
+allow_drop = true;
+selected = false;
+selectable = true;
+#ifndef QT_NO_TEXTEDIT
+renameBox = 0;
+#endif
+#ifndef QT_NO_PICTURE
+itemPic = pic;
+#endif
+if (view) {
+itemKey = itemText;
+dirty = true;
+wordWrapDirty = true;
+itemRect = QRect(-1, -1, 0, 0);
+calcRect();
+view->insertItem(this, after);
+}
+}
+/*!
+Destroys the icon view item and tells the parent icon view that
+the item has been destroyed.
+*/
+Q3IconViewItem::~Q3IconViewItem()
+{
+#ifndef QT_NO_TEXTEDIT
+removeRenameBox();
+#endif
+if (view && !view->d->clearing)
+view->takeItem(this);
+view = 0;
+if (itemIcon && itemIcon->serialNumber() != unknown_icon->serialNumber())
+delete itemIcon;
+#ifndef QT_NO_PICTURE
+delete itemPic;
+#endif
+delete d;
+}
+int Q3IconViewItem::RTTI = 0;
+/*!
+Returns 0.
+Make your derived classes return their own values for rtti(), so
+that you can distinguish between icon view item types. You should
+use values greater than 1000, preferably a large random number, to
+allow for extensions to this class.
+*/
+int Q3IconViewItem::rtti() const
+{
+return RTTI;
+}
+/*!
+Sets \a text as the text of the icon view item. This function
+might be a no-op if you reimplement text().
+\sa text()
+*/
+void Q3IconViewItem::setText(const QString &text)
+{
+if (text == itemText)
+return;
+wordWrapDirty = true;
+itemText = text;
+if (itemKey.isEmpty())
+itemKey = itemText;
+QRect oR = rect();
+calcRect();
+oR = oR.united(rect());
+if (view) {
+if (QRect(view->contentsX(), view->contentsY(),
+view->visibleWidth(), view->visibleHeight()).
+intersects(oR))
+view->repaintContents(oR.x() - 1, oR.y() - 1, oR.width() + 2, oR.height() + 2);
+}
+}
+/*!
+Sets \a k as the sort key of the icon view item. By default
+text() is used for sorting.
+\sa compare()
+*/
+void Q3IconViewItem::setKey(const QString &k)
+{
+if (k == itemKey)
+return;
+itemKey = k;
+}
+/*!
+Sets \a icon as the item's icon in the icon view. This function
+might be a no-op if you reimplement pixmap().
+\sa pixmap()
+*/
+void Q3IconViewItem::setPixmap(const QPixmap &icon)
+{
+if (itemIcon && itemIcon == unknown_icon)
+itemIcon = 0;
+if (itemIcon)
+*itemIcon = icon;
+else
+itemIcon = new QPixmap(icon);
+QRect oR = rect();
+calcRect();
+oR = oR.united(rect());
+if (view) {
+if (QRect(view->contentsX(), view->contentsY(),
+view->visibleWidth(), view->visibleHeight()).
+intersects(oR))
+view->repaintContents(oR.x() - 1, oR.y() - 1, oR.width() + 2, oR.height() + 2);
+}
+}
+/*!
+Sets \a icon as the item's icon in the icon view. This function
+might be a no-op if you reimplement picture().
+\sa picture()
+*/
+#ifndef QT_NO_PICTURE
+void Q3IconViewItem::setPicture(const QPicture &icon)
+{
+// clear assigned pixmap if any
+if (itemIcon) {
+if (itemIcon == unknown_icon) {
+itemIcon = 0;
+} else {
+delete itemIcon;
+itemIcon = 0;
+}
+}
+if (itemPic)
+delete itemPic;
+itemPic = new QPicture(icon);
+QRect oR = rect();
+calcRect();
+oR = oR.united(rect());
+if (view) {
+if (QRect(view->contentsX(), view->contentsY(),
+view->visibleWidth(), view->visibleHeight()).
+intersects(oR))
+view->repaintContents(oR.x() - 1, oR.y() - 1, oR.width() + 2, oR.height() + 2);
+}
+}
+#endif
+/*!
+\overload
+Sets \a text as the text of the icon view item. If \a recalc is
+true, the icon view's layout is recalculated. If \a redraw is true
+(the default), the icon view is repainted.
+\sa text()
+*/
+void Q3IconViewItem::setText(const QString &text, bool recalc, bool redraw)
+{
+if (text == itemText)
+return;
+wordWrapDirty = true;
+itemText = text;
+if (recalc)
+calcRect();
+if (redraw)
+repaint();
+}
+/*!
+\overload
+Sets \a icon as the item's icon in the icon view. If \a recalc is
+true, the icon view's layout is recalculated. If \a redraw is true
+(the default), the icon view is repainted.
+\sa pixmap()
+*/
+void Q3IconViewItem::setPixmap(const QPixmap &icon, bool recalc, bool redraw)
+{
+if (itemIcon && itemIcon == unknown_icon)
+itemIcon = 0;
+if (itemIcon)
+*itemIcon = icon;
+else
+itemIcon = new QPixmap(icon);
+if (redraw) {
+if (recalc) {
+QRect oR = rect();
+calcRect();
+oR = oR.united(rect());
+if (view) {
+if (QRect(view->contentsX(), view->contentsY(),
+view->visibleWidth(), view->visibleHeight()).
+intersects(oR))
+view->repaintContents(oR.x() - 1, oR.y() - 1, oR.width() + 2, oR.height() + 2);
+}
+} else {
+repaint();
+}
+} else if (recalc) {
+calcRect();
+}
+}
+/*!
+If \a allow is true, the user can rename the icon view item by
+clicking on the text (or pressing F2) while the item is selected
+(in-place renaming). If \a allow is false, in-place renaming is
+not possible.
+*/
+void Q3IconViewItem::setRenameEnabled(bool allow)
+{
+allow_rename = (uint)allow;
+}
+/*!
+If \a allow is true, the icon view permits the user to drag the
+icon view item either to another position within the icon view or
+to somewhere outside of it. If \a allow is false, the item cannot
+be dragged.
+*/
+void Q3IconViewItem::setDragEnabled(bool allow)
+{
+allow_drag = (uint)allow;
+}
+/*!
+If \a allow is true, the icon view lets the user drop something on
+this icon view item.
+*/
+void Q3IconViewItem::setDropEnabled(bool allow)
+{
+allow_drop = (uint)allow;
+}
+/*!
+Returns the text of the icon view item. Normally you set the text
+of the item with setText(), but sometimes it's inconvenient to
+call setText() for every item; so you can subclass Q3IconViewItem,
+reimplement this function, and return the text of the item. If you
+do this, you must call calcRect() manually each time the text
+(and therefore its size) changes.
+\sa setText()
+*/
+QString Q3IconViewItem::text() const
+{
+return itemText;
+}
+/*!
+Returns the key of the icon view item or text() if no key has been
+explicitly set.
+\sa setKey(), compare()
+*/
+QString Q3IconViewItem::key() const
+{
+return itemKey;
+}
+/*!
+Returns the icon of the icon view item if it is a pixmap, or 0 if
+it is a picture. In the latter case use picture() instead.
+Normally you set the pixmap of the item with setPixmap(), but
+sometimes it's inconvenient to call setPixmap() for every item. So
+you can subclass Q3IconViewItem, reimplement this function and
+return a pointer to the item's pixmap. If you do this, you \e must
+call calcRect() manually each time the size of this pixmap
+changes.
+\sa setPixmap()
+*/
+QPixmap *Q3IconViewItem::pixmap() const
+{
+return itemIcon;
+}
+/*!
+Returns the icon of the icon view item if it is a picture, or 0 if
+it is a pixmap. In the latter case use pixmap() instead. Normally
+you set the picture of the item with setPicture(), but sometimes
+it's inconvenient to call setPicture() for every item. So you can
+subclass Q3IconViewItem, reimplement this function and return a
+pointer to the item's picture. If you do this, you \e must call
+calcRect() manually each time the size of this picture changes.
+\sa setPicture()
+*/
+#ifndef QT_NO_PICTURE
+QPicture *Q3IconViewItem::picture() const
+{
+return itemPic;
+}
+#endif
+/*!
+Returns true if the item can be renamed by the user with in-place
+renaming; otherwise returns false.
+\sa setRenameEnabled()
+*/
+bool Q3IconViewItem::renameEnabled() const
+{
+return (bool)allow_rename;
+}
+/*!
+Returns true if the user is allowed to drag the icon view item;
+otherwise returns false.
+\sa setDragEnabled()
+*/
+bool Q3IconViewItem::dragEnabled() const
+{
+return (bool)allow_drag;
+}
+/*!
+Returns true if the user is allowed to drop something onto the
+item; otherwise returns false.
+\sa setDropEnabled()
+*/
+bool Q3IconViewItem::dropEnabled() const
+{
+return (bool)allow_drop;
+}
+/*!
+Returns a pointer to this item's icon view parent.
+*/
+Q3IconView *Q3IconViewItem::iconView() const
+{
+return view;
+}
+/*!
+Returns a pointer to the previous item, or 0 if this is the first
+item in the icon view.
+\sa nextItem() Q3IconView::firstItem()
+*/
+Q3IconViewItem *Q3IconViewItem::prevItem() const
+{
+return prev;
+}
+/*!
+Returns a pointer to the next item, or 0 if this is the last item
+in the icon view.
+To find the first item use Q3IconView::firstItem().
+Example:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 2
+\sa prevItem()
+*/
+Q3IconViewItem *Q3IconViewItem::nextItem() const
+{
+return next;
+}
+/*!
+Returns the index of this item in the icon view, or -1 if an error
+occurred.
+*/
+int Q3IconViewItem::index() const
+{
+if (view)
+return view->index(this);
+return -1;
+}
+/*!
+\overload
+This variant is equivalent to calling the other variant with \e cb
+set to false.
+*/
+void Q3IconViewItem::setSelected(bool s)
+{
+setSelected(s, false);
+}
+/*!
+Selects or unselects the item, depending on \a s; it may also
+unselect other items, depending on Q3IconView::selectionMode() and
+\a cb.
+If \a s is false, the item is unselected.
+If \a s is true and Q3IconView::selectionMode() is
+Q3IconView::Single, the item is selected and the item previously
+selected is unselected.
+If \a s is true and Q3IconView::selectionMode() is
+Q3IconView::Extended, the item is selected. If \a cb is true, the
+selection state of the other items is left unchanged. If \a cb is
+false (the default) all other items are unselected.
+If \a s is true and Q3IconView::selectionMode() is
+Q3IconView::Multi, the item is selected.
+Note that \a cb is used only if Q3IconView::selectionMode() is
+Q3IconView::Extended; cb defaults to false.
+All items whose selection status changes repaint themselves.
+*/
+void Q3IconViewItem::setSelected(bool s, bool cb)
+{
+if (!view)
+return;
+if (view->selectionMode() != Q3IconView::NoSelection &&
+selectable && s != (bool)selected) {
+if (view->d->selectionMode == Q3IconView::Single && this != view->d->currentItem) {
+Q3IconViewItem *o = view->d->currentItem;
+if (o && o->selected)
+o->selected = false;
+view->d->currentItem = this;
+if (o)
+o->repaint();
+emit view->currentChanged(this);
+}
+if (!s) {
+selected = false;
+} else {
+if (view->d->selectionMode == Q3IconView::Single && view->d->currentItem) {
+view->d->currentItem->selected = false;
+}
+if ((view->d->selectionMode == Q3IconView::Extended && !cb) ||
+view->d->selectionMode == Q3IconView::Single) {
+bool b = view->signalsBlocked();
+view->blockSignals(true);
+view->selectAll(false);
+view->blockSignals(b);
+}
+selected = s;
+}
+repaint();
+if (!view->signalsBlocked()) {
+bool emitIt = view->d->selectionMode == Q3IconView::Single && s;
+Q3IconView *v = view;
+emit v->selectionChanged();
+if (emitIt)
+emit v->selectionChanged(this);
+}
+}
+}
+/*!
+Sets this item to be selectable if \a enable is true (the default)
+or unselectable if \a enable is false.
+The user is unable to select a non-selectable item using either
+the keyboard or the mouse. (The application programmer can select
+an item in code regardless of this setting.)
+\sa isSelectable()
+*/
+void Q3IconViewItem::setSelectable(bool enable)
+{
+selectable = (uint)enable;
+}
+/*!
+Returns true if the item is selected; otherwise returns false.
+\sa setSelected()
+*/
+bool Q3IconViewItem::isSelected() const
+{
+return (bool)selected;
+}
+/*!
+Returns true if the item is selectable; otherwise returns false.
+\sa setSelectable()
+*/
+bool Q3IconViewItem::isSelectable() const
+{
+return (bool)selectable;
+}
+/*!
+Repaints the item.
+*/
+void Q3IconViewItem::repaint()
+{
+if (view)
+view->repaintItem(this);
+}
+/*!
+Moves the item to position (\a x, \a y) in the icon view (these
+are contents coordinates). Returns true if the item is moved.
+Returns false if the item is already at the specified position.
+*/
+bool Q3IconViewItem::move(int x, int y)
+{
+if (x == this->x() && y == this->y())
+return false;
+itemRect.setRect(x, y, itemRect.width(), itemRect.height());
+checkRect();
+if (view)
+view->updateItemContainer(this);
+return true;
+}
+/*!
+Moves the item \a dx pixels in the x-direction and \a dy pixels in
+the y-direction.
+*/
+void Q3IconViewItem::moveBy(int dx, int dy)
+{
+itemRect.moveBy(dx, dy);
+checkRect();
+if (view)
+view->updateItemContainer(this);
+}
+/*!
+\overload
+Moves the item to the point \a pnt.
+*/
+bool Q3IconViewItem::move(const QPoint &pnt)
+{
+return move(pnt.x(), pnt.y());
+}
+/*!
+\overload
+Moves the item by the x, y values in point \a pnt.
+*/
+void Q3IconViewItem::moveBy(const QPoint &pnt)
+{
+moveBy(pnt.x(), pnt.y());
+}
+/*!
+Returns the bounding rectangle of the item (in contents
+coordinates).
+*/
+QRect Q3IconViewItem::rect() const
+{
+return itemRect;
+}
+/*!
+Returns the x-coordinate of the item (in contents coordinates).
+*/
+int Q3IconViewItem::x() const
+{
+return itemRect.x();
+}
+/*!
+Returns the y-coordinate of the item (in contents coordinates).
+*/
+int Q3IconViewItem::y() const
+{
+return itemRect.y();
+}
+/*!
+Returns the width of the item.
+*/
+int Q3IconViewItem::width() const
+{
+return qMax(itemRect.width(), QApplication::globalStrut().width());
+}
+/*!
+Returns the height of the item.
+*/
+int Q3IconViewItem::height() const
+{
+return qMax(itemRect.height(), QApplication::globalStrut().height());
+}
+/*!
+Returns the size of the item.
+*/
+QSize Q3IconViewItem::size() const
+{
+return QSize(itemRect.width(), itemRect.height());
+}
+/*!
+Returns the position of the item (in contents coordinates).
+*/
+QPoint Q3IconViewItem::pos() const
+{
+return QPoint(itemRect.x(), itemRect.y());
+}
+/*!
+Returns the bounding rectangle of the item's text.
+If \a relative is true, (the default), the returned rectangle is
+relative to the origin of the item's rectangle. If \a relative is
+false, the returned rectangle is relative to the origin of the
+icon view's contents coordinate system.
+*/
+QRect Q3IconViewItem::textRect(bool relative) const
+{
+if (relative)
+return itemTextRect;
+else
+return QRect(x() + itemTextRect.x(), y() + itemTextRect.y(), itemTextRect.width(), itemTextRect.height());
+}
+/*!
+Returns the bounding rectangle of the item's icon.
+If \a relative is true, (the default), the rectangle is relative to
+the origin of the item's rectangle. If \a relative is false, the
+returned rectangle is relative to the origin of the icon view's
+contents coordinate system.
+*/
+QRect Q3IconViewItem::pixmapRect(bool relative) const
+{
+if (relative)
+return itemIconRect;
+else
+return QRect(x() + itemIconRect.x(), y() + itemIconRect.y(), itemIconRect.width(), itemIconRect.height());
+}
+/*!
+Returns true if the item contains the point \a pnt (in contents
+coordinates); otherwise returns false.
+*/
+bool Q3IconViewItem::contains(const QPoint& pnt) const
+{
+QRect textArea = textRect(false);
+QRect pixmapArea = pixmapRect(false);
+if (iconView()->itemTextPos() == Q3IconView::Bottom)
+textArea.setTop(pixmapArea.bottom());
+else
+textArea.setLeft(pixmapArea.right());
+return textArea.contains(pnt) || pixmapArea.contains(pnt);
+}
+/*!
+Returns true if the item intersects the rectangle \a r (in
+contents coordinates); otherwise returns false.
+*/
+bool Q3IconViewItem::intersects(const QRect& r) const
+{
+return (textRect(false).intersects(r) ||
+pixmapRect(false).intersects(r));
+}
+/*!
+\fn bool Q3IconViewItem::acceptDrop(const QMimeSource *mime) const
+Returns true if you can drop things with a QMimeSource of \a mime
+onto this item; otherwise returns false.
+The default implementation always returns false. You must subclass
+Q3IconViewItem and reimplement acceptDrop() to accept drops.
+*/
+bool Q3IconViewItem::acceptDrop(const QMimeSource *) const
+{
+return false;
+}
+#ifndef QT_NO_TEXTEDIT
+/*!
+Starts in-place renaming of an icon, if allowed.
+This function sets up the icon view so that the user can edit the
+item text, and then returns. When the user is done, setText() will
+be called and Q3IconView::itemRenamed() will be emitted (unless the
+user canceled, e.g. by pressing the Escape key).
+\sa setRenameEnabled()
+*/
+void Q3IconViewItem::rename()
+{
+if (!view)
+return;
+if (renameBox)
+removeRenameBox();
+oldRect = rect();
+renameBox = new Q3IconViewItemLineEdit(itemText, view->viewport(), this, "qt_renamebox");
+iconView()->ensureItemVisible(this);
+QRect tr(textRect(false));
+view->addChild(renameBox, tr.x() + (tr.width() / 2 - renameBox->width() / 2), tr.y() - 3);
+renameBox->selectAll();
+view->viewport()->setFocusProxy(renameBox);
+renameBox->setFocus();
+renameBox->show();
+Q_ASSERT(view->d->renamingItem == 0L);
+view->d->renamingItem = this;
+}
+#endif
+/*!
+Compares this icon view item to \a i. Returns -1 if this item is
+less than \a i, 0 if they are equal, and 1 if this icon view item
+is greater than \a i.
+The default implementation compares the item keys (key()) using
+QString::localeAwareCompare(). A reimplementation may use
+different values and a different comparison function. Here is a
+reimplementation that uses plain Unicode comparison:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 3
+\sa key() QString::localeAwareCompare() QString::compare()
+*/
+int Q3IconViewItem::compare(Q3IconViewItem *i) const
+{
+return key().localeAwareCompare(i->key());
+}
+#ifndef QT_NO_TEXTEDIT
+/*!
+This private function is called when the user pressed Return during
+in-place renaming.
+*/
+void Q3IconViewItem::renameItem()
+{
+if (!renameBox || !view)
+return;
+if (!view->d->wordWrapIconText) {
+wordWrapDirty = true;
+calcRect();
+}
+QRect r = itemRect;
+setText(renameBox->text());
+view->repaintContents(oldRect.x() - 1, oldRect.y() - 1, oldRect.width() + 2, oldRect.height() + 2);
+view->repaintContents(r.x() - 1, r.y() - 1, r.width() + 2, r.height() + 2);
+removeRenameBox();
+view->emitRenamed(this);
+}
+/*!
+Cancels in-place renaming.
+*/
+void Q3IconViewItem::cancelRenameItem()
+{
+if (!view)
+return;
+QRect r = itemRect;
+calcRect();
+view->repaintContents(oldRect.x() - 1, oldRect.y() - 1, oldRect.width() + 2, oldRect.height() + 2);
+view->repaintContents(r.x() - 1, r.y() - 1, r.width() + 2, r.height() + 2);
+if (!renameBox)
+return;
+removeRenameBox();
+}
+/*!
+Removes the editbox that is used for in-place renaming.
+*/
+void Q3IconViewItem::removeRenameBox()
+{
+if (!renameBox || !view)
+return;
+bool resetFocus = view->viewport()->focusProxy() == renameBox;
+renameBox->hide();
+renameBox->deleteLater();
+renameBox = 0;
+if (resetFocus) {
+view->viewport()->setFocusProxy(view);
+view->setFocus();
+}
+Q_ASSERT(view->d->renamingItem == this);
+view->d->renamingItem = 0L;
+}
+#endif
+/*!
+This virtual function is responsible for calculating the
+rectangles returned by rect(), textRect() and pixmapRect().
+setRect(), setTextRect() and setPixmapRect() are provided mainly
+for reimplementations of this function.
+\a text_ is an internal parameter which defaults to an empty
+string.
+*/
+void Q3IconViewItem::calcRect(const QString &text_)
+{
+if (!view) // #####
+return;
+wordWrapDirty = true;
+int pw = 0;
+int ph = 0;
+#ifndef QT_NO_PICTURE
+if (picture()) {
+QRect br = picture()->boundingRect();
+pw = br.width() + 2;
+ph = br.height() + 2;
+} else
+#endif
+{
+pw = (pixmap() ? pixmap() : unknown_icon)->width() + 2;
+ph = (pixmap() ? pixmap() : unknown_icon)->height() + 2;
+}
+itemIconRect.setWidth(pw);
+itemIconRect.setHeight(ph);
+calcTmpText();
+QString t = text_;
+if (t.isEmpty()) {
+if (view->d->wordWrapIconText)
+t = itemText;
+else
+t = tmpText;
+}
+int tw = 0;
+int th = 0;
+// ##### TODO: fix font bearings!
+QRect r;
+if (view->d->wordWrapIconText) {
+r = QRect(view->d->fm->boundingRect(0, 0, iconView()->maxItemWidth() -
+(iconView()->itemTextPos() == Q3IconView::Bottom ? 0 :
+pixmapRect().width()),
+0xFFFFFFFF, Qt::AlignHCenter | Qt::WordBreak | Qt::BreakAnywhere, t));
+r.setWidth(r.width() + 4);
+} else {
+r = QRect(0, 0, view->d->fm->width(t), view->d->fm->height());
+r.setWidth(r.width() + 4);
+}
+if (r.width() > iconView()->maxItemWidth() -
+(iconView()->itemTextPos() == Q3IconView::Bottom ? 0 :
+pixmapRect().width()))
+r.setWidth(iconView()->maxItemWidth() - (iconView()->itemTextPos() == Q3IconView::Bottom ? 0 :
+pixmapRect().width()));
+tw = r.width();
+th = r.height();
+if (tw < view->d->fm->width(QLatin1Char('X')))
+tw = view->d->fm->width(QLatin1Char('X'));
+itemTextRect.setWidth(tw);
+itemTextRect.setHeight(th);
+int w = 0;
+int h = 0;
+if (view->itemTextPos() == Q3IconView::Bottom) {
+w = qMax(itemTextRect.width(), itemIconRect.width());
+h = itemTextRect.height() + itemIconRect.height() + 1;
+itemRect.setWidth(w);
+itemRect.setHeight(h);
+itemTextRect = QRect((width() - itemTextRect.width()) / 2, height() - itemTextRect.height(),
+itemTextRect.width(), itemTextRect.height());
+itemIconRect = QRect((width() - itemIconRect.width()) / 2, 0,
+itemIconRect.width(), itemIconRect.height());
+} else {
+h = qMax(itemTextRect.height(), itemIconRect.height());
+w = itemTextRect.width() + itemIconRect.width() + 1;
+itemRect.setWidth(w);
+itemRect.setHeight(h);
+itemTextRect = QRect(width() - itemTextRect.width(), (height() - itemTextRect.height()) / 2,
+itemTextRect.width(), itemTextRect.height());
+itemIconRect = QRect(0, (height() - itemIconRect.height()) / 2,
+itemIconRect.width(), itemIconRect.height());
+}
+if (view)
+view->updateItemContainer(this);
+}
+/*!
+Paints the item using the painter \a p and the color group \a cg.
+If you want the item to be drawn with a different font or color,
+reimplement this function, change the values of the color group or
+the painter's font, and then call the Q3IconViewItem::paintItem()
+with the changed values.
+*/
+void Q3IconViewItem::paintItem(QPainter *p, const QColorGroup &cg)
+{
+if (!view)
+return;
+p->save();
+if (isSelected()) {
+p->setPen(cg.highlightedText());
+} else {
+p->setPen(cg.text());
+}
+calcTmpText();
+#ifndef QT_NO_PICTURE
+if (picture()) {
+QPicture *pic = picture();
+if (isSelected()) {
+p->fillRect(pixmapRect(false), QBrush(cg.highlight(), Qt::Dense4Pattern));
+}
+p->drawPicture(x()-pic->boundingRect().x(), y()-pic->boundingRect().y(), *pic);
+if (isSelected()) {
+p->fillRect(textRect(false), cg.highlight());
+p->setPen(QPen(cg.highlightedText()));
+} else if (view->d->itemTextBrush != QBrush(Qt::NoBrush))
+p->fillRect(textRect(false), view->d->itemTextBrush);
+int align = view->itemTextPos() == Q3IconView::Bottom ? Qt::AlignHCenter : Qt::AlignAuto;
+if (view->d->wordWrapIconText)
+align |= Qt::WordBreak | Qt::BreakAnywhere;
+p->drawText(textRect(false), align, view->d->wordWrapIconText ? itemText : tmpText);
+p->restore();
+return;
+}
+#endif
+bool textOnBottom = (view->itemTextPos() == Q3IconView::Bottom);
+int dim;
+if (textOnBottom)
+dim = (pixmap() ? pixmap() : unknown_icon)->width();
+else
+dim = (pixmap() ? pixmap() : unknown_icon)->height();
+if (isSelected()) {
+QPixmap *pix = pixmap() ? pixmap() : unknown_icon;
+if (pix && !pix->isNull()) {
+QPixmap *buffer = get_qiv_buffer_pixmap(pix->size());
+QBitmap mask = view->mask(pix);
+QPainter p2(buffer);
+p2.fillRect(pix->rect(), Qt::white);
+p2.drawPixmap(0, 0, *pix);
+p2.end();
+p2.begin(buffer);
+p2.fillRect(pix->rect(), QBrush(cg.highlight(), Qt::Dense4Pattern));
+p2.end();
+buffer->setMask(mask);
+QRect cr = pix->rect();
+if (textOnBottom)
+p->drawPixmap(x() + (width() - dim) / 2, y(), *buffer, 0, 0,
+cr.width(), cr.height());
+else
+p->drawPixmap(x() , y() + (height() - dim) / 2, *buffer, 0, 0,
+cr.width(), cr.height());
+}
+} else {
+if (textOnBottom)
+p->drawPixmap(x() + (width() - dim) / 2, y(),
+*(pixmap() ? pixmap() : unknown_icon));
+else
+p->drawPixmap(x() , y() + (height() - dim) / 2,
+*(pixmap() ? pixmap() : unknown_icon));
+}
+p->save();
+if (isSelected()) {
+p->fillRect(textRect(false), cg.highlight());
+p->setPen(QPen(cg.highlightedText()));
+} else if (view->d->itemTextBrush != QBrush(Qt::NoBrush))
+p->fillRect(textRect(false), view->d->itemTextBrush);
+int align = Qt::AlignHCenter;
+if (view->d->wordWrapIconText)
+align |= Qt::WordBreak | Qt::BreakAnywhere;
+p->drawText(textRect(false), align,
+view->d->wordWrapIconText ? itemText : tmpText);
+p->restore();
+p->restore();
+}
+/*!
+Paints the focus rectangle of the item using the painter \a p and
+the color group \a cg.
+*/
+void Q3IconViewItem::paintFocus(QPainter *p, const QColorGroup &cg)
+{
+if (!view)
+return;
+QStyleOptionFocusRect opt;
+opt.rect = textRect(false);
+opt.palette = cg;
+if (isSelected()) {
+opt.state = QStyle::State_FocusAtBorder;
+opt.backgroundColor = cg.highlight();
+} else {
+opt.state = QStyle::State_None;
+opt.backgroundColor = cg.base();
+}
+view->style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p);
+if (this != view->d->currentItem) {
+opt.rect = pixmapRect(false);
+opt.backgroundColor = cg.base();
+opt.state = QStyle::State_None;
+view->style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p);
+}
+}
+#ifndef QT_NO_DRAGANDDROP
+/*!
+\fn void Q3IconViewItem::dropped(QDropEvent *e, const Q3ValueList<Q3IconDragItem> &lst)
+This function is called when something is dropped on the item. \a
+e provides all the information about the drop. If the drag object
+of the drop was a Q3IconDrag, \a lst contains the list of the
+dropped items. You can get the data by calling
+Q3IconDragItem::data() on each item. If the \a lst is empty, i.e.
+the drag was not a Q3IconDrag, you must decode the data in \a e and
+work with that.
+The default implementation does nothing; subclasses may
+reimplement this function.
+*/
+void Q3IconViewItem::dropped(QDropEvent *, const Q3ValueList<Q3IconDragItem> &)
+{
+}
+#endif
+/*!
+This function is called when a drag enters the item's bounding
+rectangle.
+The default implementation does nothing; subclasses may
+reimplement this function.
+*/
+void Q3IconViewItem::dragEntered()
+{
+}
+/*!
+This function is called when a drag leaves the item's bounding
+rectangle.
+The default implementation does nothing; subclasses may
+reimplement this function.
+*/
+void Q3IconViewItem::dragLeft()
+{
+}
+/*!
+Sets the bounding rectangle of the whole item to \a r. This
+function is provided for subclasses which reimplement calcRect(),
+so that they can set the calculated rectangle. \e{Any other use is
+discouraged.}
+\sa calcRect() textRect() setTextRect() pixmapRect() setPixmapRect()
+*/
+void Q3IconViewItem::setItemRect(const QRect &r)
+{
+itemRect = r;
+checkRect();
+if (view)
+view->updateItemContainer(this);
+}
+/*!
+Sets the bounding rectangle of the item's text to \a r. This
+function is provided for subclasses which reimplement calcRect(),
+so that they can set the calculated rectangle. \e{Any other use is
+discouraged.}
+\sa calcRect() textRect() setItemRect() setPixmapRect()
+*/
+void Q3IconViewItem::setTextRect(const QRect &r)
+{
+itemTextRect = r;
+if (view)
+view->updateItemContainer(this);
+}
+/*!
+Sets the bounding rectangle of the item's icon to \a r. This
+function is provided for subclasses which reimplement calcRect(),
+so that they can set the calculated rectangle. \e{Any other use is
+discouraged.}
+\sa calcRect() pixmapRect() setItemRect() setTextRect()
+*/
+void Q3IconViewItem::setPixmapRect(const QRect &r)
+{
+itemIconRect = r;
+if (view)
+view->updateItemContainer(this);
+}
+/*!
+\internal
+*/
+void Q3IconViewItem::calcTmpText()
+{
+if (!view || view->d->wordWrapIconText || !wordWrapDirty)
+return;
+wordWrapDirty = false;
+int w = iconView()->maxItemWidth() - (iconView()->itemTextPos() == Q3IconView::Bottom ? 0 :
+pixmapRect().width());
+if (view->d->fm->width(itemText) < w) {
+tmpText = itemText;
+return;
+}
+tmpText = QLatin1String("...");
+int i = 0;
+while (view->d->fm->width(tmpText + itemText[i]) < w)
+tmpText += itemText[i++];
+tmpText.remove((uint)0, 3);
+tmpText += QLatin1String("...");
+}
+/*! \internal */
+QString Q3IconViewItem::tempText() const
+{
+return tmpText;
+}
+void Q3IconViewItem::checkRect()
+{
+int x = itemRect.x();
+int y = itemRect.y();
+int w = itemRect.width();
+int h = itemRect.height();
+bool changed = false;
+if (x < 0) {
+x = 0;
+changed = true;
+}
+if (y < 0) {
+y = 0;
+changed = true;
+}
+if (changed)
+itemRect.setRect(x, y, w, h);
+}
+/*!
+\class Q3IconView
+\brief The Q3IconView class provides an area with movable labelled icons.
+\compat
+A Q3IconView can display and manage a grid or other 2D layout of
+labelled icons. Each labelled icon is a Q3IconViewItem. Items
+(Q3IconViewItems) can be added or deleted at any time; items can be
+moved within the Q3IconView. Single or multiple items can be
+selected. Items can be renamed in-place. Q3IconView also supports
+\link #draganddrop drag and drop\endlink.
+Each item contains a label string, a pixmap or picture (the icon
+itself) and optionally a sort key. The sort key is used for
+sorting the items and defaults to the label string. The label
+string can be displayed below or to the right of the icon (see \l
+ItemTextPos).
+The simplest way to create a Q3IconView is to create a Q3IconView
+object and create some Q3IconViewItems with the Q3IconView as their
+parent, set the icon view's geometry and show it.
+For example:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 4
+The Q3IconViewItem call passes a pointer to the Q3IconView we wish to
+populate, along with the label text and a QPixmap.
+When an item is inserted the Q3IconView allocates a position for it.
+Existing items are rearranged if autoArrange() is true. The
+default arrangement is \l LeftToRight -- the Q3IconView fills up
+the \e left-most column from top to bottom, then moves one column
+\e right and fills that from top to bottom and so on. The
+arrangement can be modified with any of the following approaches:
+\list
+\i Call setArrangement(), e.g. with \l TopToBottom which will fill
+the \e top-most row from left to right, then moves one row \e down
+and fills that row from left to right and so on.
+\i Construct each Q3IconViewItem using a constructor which allows
+you to specify which item the new one is to follow.
+\i Call setSorting() or sort() to sort the items.
+\endlist
+The spacing between items is set with setSpacing(). Items can be
+laid out using a fixed grid using setGridX() and setGridY(); by
+default the Q3IconView calculates a grid dynamically. The position
+of items' label text is set with setItemTextPos(). The text's
+background can be set with setItemTextBackground(). The maximum
+width of an item and of its text are set with setMaxItemWidth()
+and setMaxItemTextLength(). The label text will be word-wrapped if
+it is too long; this is controlled by setWordWrapIconText(). If
+the label text is truncated, the user can still see the entire
+text in a tool tip if they hover the mouse over the item. This is
+controlled with setShowToolTips().
+Items which are \link Q3IconViewItem::isSelectable()
+selectable\endlink may be selected depending on the SelectionMode;
+the default is \l Single. Because Q3IconView offers multiple
+selection it must display keyboard focus and selection state
+separately. Therefore there are functions to set the selection
+state of an item (setSelected()) and to select which item displays
+keyboard focus (setCurrentItem()). When multiple items may be
+selected the icon view provides a rubberband, too.
+When in-place renaming is enabled (it is disabled by default), the
+user may change the item's label. They do this by selecting the item
+(single clicking it or navigating to it with the arrow keys), then
+single clicking it (or pressing F2), and entering their text. If no
+key has been set with Q3IconViewItem::setKey() the new text will also
+serve as the key. (See Q3IconViewItem::setRenameEnabled().)
+You can control whether users can move items themselves with
+setItemsMovable().
+Because the internal structure used to store the icon view items is
+linear, no iterator class is needed to iterate over all the items.
+Instead we iterate by getting the first item from the \e{icon view}
+and then each subsequent (\l Q3IconViewItem::nextItem()) from each
+\e item in turn:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 5
+Q3IconView also provides currentItem(). You can search for an item
+using findItem() (searching by position or for label text) and
+with findFirstVisibleItem() and findLastVisibleItem(). The number
+of items is returned by count(). An item can be removed from an
+icon view using takeItem(); to delete an item use \c delete. All
+the items can be deleted with clear().
+The Q3IconView emits a wide range of useful signals, including
+selectionChanged(), currentChanged(), clicked(), moved() and
+itemRenamed().
+\target draganddrop
+\section1 Drag and Drop
+Q3IconView supports the drag and drop of items within the Q3IconView
+itself. It also supports the drag and drop of items out of or into
+the Q3IconView and drag and drop onto items themselves. The drag and
+drop of items outside the Q3IconView can be achieved in a simple way
+with basic functionality, or in a more sophisticated way which
+provides more power and control.
+The simple approach to dragging items out of the icon view is to
+subclass Q3IconView and reimplement Q3IconView::dragObject().
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 6
+In this example we create a Q3TextDrag object, (derived from
+Q3DragObject), containing the item's label and return it as the drag
+object. We could just as easily have created a Q3ImageDrag from the
+item's pixmap and returned that instead.
+Q3IconViews and their Q3IconViewItems can also be the targets of drag
+and drops. To make the Q3IconView itself able to accept drops connect
+to the dropped() signal. When a drop occurs this signal will be
+emitted with a QDragEvent and a QLinkedList of Q3IconDragItems. To
+make a Q3IconViewItem into a drop target subclass Q3IconViewItem and
+reimplement Q3IconViewItem::acceptDrop() and
+Q3IconViewItem::dropped().
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 7
+If you want to use extended drag-and-drop or have drag shapes drawn
+you must take a more sophisticated approach.
+The first part is starting drags -- you should use a Q3IconDrag (or a
+class derived from it) for the drag object. In dragObject() create the
+drag object, populate it with Q3IconDragItems and return it. Normally
+such a drag should offer each selected item's data. So in dragObject()
+you should iterate over all the items, and create a Q3IconDragItem for
+each selected item, and append these items with Q3IconDrag::append() to
+the Q3IconDrag object. You can use Q3IconDragItem::setData() to set the
+data of each item that should be dragged. If you want to offer the
+data in additional mime-types, it's best to use a class derived from
+Q3IconDrag, which implements additional encoding and decoding
+functions.
+When a drag enters the icon view, there is little to do. Simply
+connect to the dropped() signal and reimplement
+Q3IconViewItem::acceptDrop() and Q3IconViewItem::dropped(). If you've
+used a Q3IconDrag (or a subclass of it) the second argument to the
+dropped signal contains a QLinkedList of Q3IconDragItems -- you can
+access their data by calling Q3IconDragItem::data() on each one.
+For an example implementation of complex drag-and-drop look at the
+fileiconview example (qt/examples/fileiconview).
+\sa Q3IconViewItem::setDragEnabled(), Q3IconViewItem::setDropEnabled(),
+Q3IconViewItem::acceptDrop(), Q3IconViewItem::dropped()
+*/
+/*! \enum Q3IconView::ResizeMode
+This enum type is used to tell Q3IconView how it should treat the
+positions of its icons when the widget is resized. The modes are:
+\value Fixed  The icons' positions are not changed.
+\value Adjust  The icons' positions are adjusted to be within the
+new geometry, if possible.
+*/
+/*!
+\enum Q3IconView::SelectionMode
+This enumerated type is used by Q3IconView to indicate how it
+reacts to selection by the user. It has four values:
+\value Single  When the user selects an item, any already-selected
+item becomes unselected and the user cannot unselect the selected
+item. This means that the user can never clear the selection. (The
+application programmer can, using Q3IconView::clearSelection().)
+\value Multi  When the user selects an item, e.g. by navigating to
+it with the keyboard arrow keys or by clicking it, the selection
+status of that item is toggled and the other items are left alone.
+\value Extended  When the user selects an item the selection is
+cleared and the new item selected. However, if the user presses
+the Ctrl key when clicking on an item, the clicked item gets
+toggled and all other items are left untouched. If the user
+presses the Shift key while clicking on an item, all items between
+the current item and the clicked item get selected or unselected,
+depending on the state of the clicked item. Also, multiple items
+can be selected by dragging the mouse while the left mouse button
+stays pressed.
+\value NoSelection  Items cannot be selected.
+To summarize: \c Single is a real single-selection icon view; \c
+Multi a real multi-selection icon view; \c Extended is an icon
+view in which users can select multiple items but usually want to
+select either just one or a range of contiguous items; and \c
+NoSelection mode is for an icon view where the user can look but
+not touch.
+*/
+/*!
+\enum Q3IconView::Arrangement
+This enum type determines in which direction the items flow when
+the view runs out of space.
+\value LeftToRight  Items which don't fit into the view go further
+down (you get a vertical scroll bar)
+\value TopToBottom  Items which don't fit into the view go further
+right (you get a horizontal scroll bar)
+*/
+/*!
+\enum Q3IconView::ItemTextPos
+This enum type specifies the position of the item text in relation
+to the icon.
+\value Bottom  The text is drawn below the icon.
+\value Right  The text is drawn to the right of the icon.
+*/
+/*!
+\fn void Q3IconView::dropped(QDropEvent *e, const Q3ValueList<Q3IconDragItem> &lst)
+This signal is emitted when a drop event occurs in the viewport
+(but not on any icon) which the icon view itself can't handle.
+\a e provides all the information about the drop. If the drag
+object of the drop was a Q3IconDrag, \a lst contains the list of
+the dropped items. You can get the data using
+Q3IconDragItem::data() on each item. If the \a lst is empty, i.e.
+the drag was not a Q3IconDrag, you have to decode the data in \a e
+and work with that.
+Note Q3IconViewItems may be drop targets; if a drop event occurs on
+an item the item handles the drop.
+*/
+/*!
+\fn void Q3IconView::moved()
+This signal is emitted after successfully dropping one (or more)
+items of the icon view. If the items should be removed, it's best
+to do so in a slot connected to this signal.
+*/
+/*!
+\fn void  Q3IconView::doubleClicked(Q3IconViewItem * item)
+This signal is emitted when the user double-clicks on \a item.
+*/
+/*!
+\fn void  Q3IconView::returnPressed (Q3IconViewItem * item)
+This signal is emitted if the user presses the Return or Enter
+key. \a item is the currentItem() at the time of the keypress.
+*/
+/*!
+\fn void  Q3IconView::selectionChanged()
+This signal is emitted when the selection has been changed. It's
+emitted in each selection mode.
+*/
+/*!
+\fn void Q3IconView::selectionChanged(Q3IconViewItem *item)
+\overload
+This signal is emitted when the selection changes. \a item is the
+newly selected item. This signal is emitted only in single
+selection mode.
+*/
+/*!
+\fn void Q3IconView::currentChanged(Q3IconViewItem *item)
+This signal is emitted when a new item becomes current. \a item is
+the new current item (or 0 if no item is now current).
+\sa currentItem()
+*/
+/*!
+\fn void  Q3IconView::onItem(Q3IconViewItem *item)
+This signal is emitted when the user moves the mouse cursor onto
+an \a item, similar to the QWidget::enterEvent() function.
+*/
+// ### bug here - enter/leave event aren't considered. move the mouse
+// out of the window and back in, to the same item.
+/*!
+\fn void Q3IconView::onViewport()
+This signal is emitted when the user moves the mouse cursor from
+an item to an empty part of the icon view.
+\sa onItem()
+*/
+/*!
+\fn void Q3IconView::itemRenamed (Q3IconViewItem * item)
+\overload
+This signal is emitted when \a item has been renamed, usually by
+in-place renaming.
+\sa Q3IconViewItem::setRenameEnabled() Q3IconViewItem::rename()
+*/
+/*!
+\fn void Q3IconView::itemRenamed (Q3IconViewItem * item, const QString &name)
+This signal is emitted when \a item has been renamed to \a name,
+usually by in-place renaming.
+\sa Q3IconViewItem::setRenameEnabled() Q3IconViewItem::rename()
+*/
+/*!
+\fn void Q3IconView::rightButtonClicked (Q3IconViewItem * item, const QPoint & pos)
+This signal is emitted when the user clicks the right mouse
+button. If \a item is non-null, the cursor is on \a item. If \a
+item is null, the mouse cursor isn't on any item.
+\a pos is the position of the mouse cursor in the global
+coordinate system (QMouseEvent::globalPos()). (If the click's
+press and release differ by a pixel or two, \a pos is the
+position at release time.)
+\sa rightButtonPressed() mouseButtonClicked() clicked()
+*/
+/*!
+\fn void Q3IconView::contextMenuRequested(Q3IconViewItem *item, const QPoint & pos)
+This signal is emitted when the user invokes a context menu with
+the right mouse button or with special system keys, with \a item
+being the item under the mouse cursor or the current item,
+respectively.
+\a pos is the position for the context menu in the global
+coordinate system.
+*/
+/*!
+\fn void Q3IconView::mouseButtonPressed(int button, Q3IconViewItem *item, const QPoint &pos)
+This signal is emitted when the user presses mouse button \a
+button. If \a item is non-null, the cursor is on \a item. If \a
+item is null, the mouse cursor isn't on any item.
+\a pos is the position of the mouse cursor in the global
+coordinate system (QMouseEvent::globalPos()).
+\sa rightButtonClicked() mouseButtonClicked() pressed()
+*/
+/*!
+\fn void Q3IconView::mouseButtonClicked (int button, Q3IconViewItem * item, const QPoint & pos)
+This signal is emitted when the user clicks mouse button \a
+button. If \a item is non-null, the cursor is on \a item. If \a
+item is null, the mouse cursor isn't on any item.
+\a pos is the position of the mouse cursor in the global
+coordinate system (QMouseEvent::globalPos()). (If the click's
+press and release differ by a pixel or two, \a pos is the
+position at release time.)
+\sa mouseButtonPressed() rightButtonClicked() clicked()
+*/
+/*!
+\fn void Q3IconView::clicked (Q3IconViewItem * item, const QPoint & pos)
+\overload
+This signal is emitted when the user clicks any mouse button on an
+icon view item. \a item is a pointer to the item that has been
+clicked.
+\a pos is the position of the mouse cursor in the global coordinate
+system (QMouseEvent::globalPos()). (If the click's press and release
+differ by a pixel or two, \a pos is the  position at release time.)
+\sa mouseButtonClicked() rightButtonClicked() pressed()
+*/
+/*!
+\fn void Q3IconView::pressed (Q3IconViewItem * item, const QPoint & pos)
+\overload
+This signal is emitted when the user presses any mouse button. If
+\a item is non-null, the cursor is on \a item. If \a item is null,
+the mouse cursor isn't on any item.
+\a pos is the position of the mouse cursor in the global
+coordinate system (QMouseEvent::globalPos()). (If the click's
+press and release differ by a pixel or two, \a pos is the
+position at release time.)
+\sa mouseButtonPressed() rightButtonPressed() clicked()
+*/
+/*!
+\fn void Q3IconView::clicked (Q3IconViewItem * item)
+This signal is emitted when the user clicks any mouse button. If
+\a item is non-null, the cursor is on \a item. If \a item is null,
+the mouse cursor isn't on any item.
+\sa mouseButtonClicked() rightButtonClicked() pressed()
+*/
+/*!
+\fn void Q3IconView::pressed (Q3IconViewItem * item)
+This signal is emitted when the user presses any mouse button. If
+\a item is non-null, the cursor is on \a item. If \a item is null,
+the mouse cursor isn't on any item.
+\sa mouseButtonPressed() rightButtonPressed() clicked()
+*/
+/*!
+\fn void Q3IconView::rightButtonPressed(Q3IconViewItem * item, const QPoint & pos)
+This signal is emitted when the user presses the right mouse
+button. If \a item is non-null, the cursor is on \a item. If \a
+item is null, the mouse cursor isn't on any item.
+\a pos is the position of the mouse cursor in the global
+coordinate system (QMouseEvent::globalPos()).
+*/
+/*!
+Constructs an empty icon view called \a name, with parent \a
+parent and using the widget flags \a f.
+*/
+Q3IconView::Q3IconView(QWidget *parent, const char *name, Qt::WindowFlags f)
+: Q3ScrollView(parent, name, Qt::WStaticContents | Qt::WNoAutoErase  | f)
+{
+if (!unknown_icon) {
+unknown_icon = new QPixmap((const char **)unknown_xpm);
+qiv_cleanup_pixmap.add(&unknown_icon);
+}
+d = new Q3IconViewPrivate;
+d->dragging = false;
+d->firstItem = 0;
+d->lastItem = 0;
+d->count = 0;
+d->mousePressed = false;
+d->selectionMode = Single;
+d->currentItem = 0;
+d->highlightedItem = 0;
+d->rubber = 0;
+d->scrollTimer = 0;
+d->startDragItem = 0;
+d->tmpCurrentItem = 0;
+d->rastX = d->rastY = -1;
+d->spacing = 5;
+d->cleared = false;
+d->arrangement = LeftToRight;
+d->resizeMode = Fixed;
+d->dropped = false;
+d->adjustTimer = new QTimer(this, "iconview adjust timer");
+d->isIconDrag = false;
+d->inMenuMode = false;
+#ifndef QT_NO_DRAGANDDROP
+d->iconDragData.clear();
+#endif
+d->numDragItems = 0;
+d->updateTimer = new QTimer(this, "iconview update timer");
+d->cachedW = d->cachedH = 0;
+d->maxItemWidth = 100;
+d->maxItemTextLength = 255;
+d->inputTimer = new QTimer(this, "iconview input timer");
+d->currInputString.clear();
+d->dirty = false;
+d->rearrangeEnabled = true;
+d->itemTextPos = Bottom;
+d->reorderItemsWhenInsert = true;
+#ifndef QT_NO_CURSOR
+d->oldCursor = Qt::ArrowCursor;
+#endif
+d->resortItemsWhenInsert = false;
+d->sortDirection = true;
+d->wordWrapIconText = true;
+d->cachedContentsX = d->cachedContentsY = -1;
+d->clearing = false;
+d->fullRedrawTimer = new QTimer(this, "iconview full redraw timer");
+d->itemTextBrush = Qt::NoBrush;
+d->drawAllBack = true;
+d->fm = new QFontMetrics(font());
+d->minLeftBearing = d->fm->minLeftBearing();
+d->minRightBearing = d->fm->minRightBearing();
+d->firstContainer = d->lastContainer = 0;
+d->containerUpdateLocked = false;
+d->firstSizeHint = false;
+d->selectAnchor = 0;
+d->renamingItem = 0;
+d->drawActiveSelection = true;
+d->drawDragShapes = false;
+connect(d->adjustTimer, SIGNAL(timeout()),
+this, SLOT(adjustItems()));
+connect(d->updateTimer, SIGNAL(timeout()),
+this, SLOT(slotUpdate()));
+connect(d->fullRedrawTimer, SIGNAL(timeout()),
+this, SLOT(updateContents()));
+connect(this, SIGNAL(contentsMoving(int,int)),
+this, SLOT(movedContents(int,int)));
+setAcceptDrops(true);
+viewport()->setAcceptDrops(true);
+setMouseTracking(true);
+viewport()->setMouseTracking(true);
+viewport()->setBackgroundRole(QPalette::Base);
+viewport()->setFocusProxy(this);
+viewport()->setFocusPolicy(Qt::WheelFocus);
+setFocusPolicy(Qt::WheelFocus);
+d->showTips = true;
+}
+/*!
+\reimp
+*/
+void Q3IconView::changeEvent(QEvent *ev)
+{
+if(ev->type() == QEvent::StyleChange) {
+*d->fm = QFontMetrics(font());
+d->minLeftBearing = d->fm->minLeftBearing();
+d->minRightBearing = d->fm->minRightBearing();
+Q3IconViewItem *item = d->firstItem;
+for (; item; item = item->next) {
+item->wordWrapDirty = true;
+item->calcRect();
+}
+#if !defined(Q_WS_X11)
+delete qiv_selection;
+qiv_selection = 0;
+#endif
+} else if(ev->type() == QEvent::ActivationChange) {
+if (!isActiveWindow() && d->scrollTimer)
+d->scrollTimer->stop();
+if(isVisible() && !palette().isEqual(QPalette::Active, QPalette::Inactive))
+repaintSelectedItems();
+}
+Q3ScrollView::changeEvent(ev);
+if (ev->type() == QEvent::ApplicationFontChange || ev->type() == QEvent::FontChange) {
+*d->fm = QFontMetrics(font());
+d->minLeftBearing = d->fm->minLeftBearing();
+d->minRightBearing = d->fm->minRightBearing();
+Q3IconViewItem *item = d->firstItem;
+for (; item; item = item->next) {
+item->wordWrapDirty = true;
+item->calcRect();
+}
+}
+}
+/*!
+Destroys the icon view and deletes all items.
+*/
+Q3IconView::~Q3IconView()
+{
+Q3IconViewItem *tmp, *item = d->firstItem;
+d->clearing = true;
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer, *tmpc;
+while (c) {
+tmpc = c->n;
+delete c;
+c = tmpc;
+}
+while (item) {
+tmp = item->next;
+delete item;
+item = tmp;
+}
+delete d->fm;
+d->fm = 0;
+delete d;
+}
+/*!
+Inserts the icon view item \a item after \a after. If \a after is
+0, \a item is appended after the last item.
+\e{You should never need to call this function.} Instead create
+Q3IconViewItem's and associate them with your icon view like this:
+\snippet doc/src/snippets/code/src_qt3support_itemviews_q3iconview.cpp 8
+*/
+void Q3IconView::insertItem(Q3IconViewItem *item, Q3IconViewItem *after)
+{
+if (!item)
+return;
+if (d->firstItem == item || item->prev || item->next)
+return;
+if (!item->view)
+item->view = this;
+if (!d->firstItem) {
+d->firstItem = d->lastItem = item;
+item->prev = 0;
+item->next = 0;
+} else {
+if (!after || after == d->lastItem) {
+d->lastItem->next = item;
+item->prev = d->lastItem;
+item->next = 0;
+d->lastItem = item;
+} else {
+Q3IconViewItem *i = d->firstItem;
+while (i != after)
+i = i->next;
+if (i) {
+Q3IconViewItem *next = i->next;
+item->next = next;
+item->prev = i;
+i->next = item;
+next->prev = item;
+}
+}
+}
+if (isVisible()) {
+if (d->reorderItemsWhenInsert) {
+if (d->updateTimer->isActive())
+d->updateTimer->stop();
+d->fullRedrawTimer->stop();
+// #### uncomment this ASA insertInGrid uses cached values and is efficient
+//insertInGrid(item);
+d->cachedW = qMax(d->cachedW, item->x() + item->width());
+d->cachedH= qMax(d->cachedH, item->y() + item->height());
+d->updateTimer->start(0, true);
+} else {
+insertInGrid(item);
+viewport()->update(item->x() - contentsX(),
+item->y() - contentsY(),
+item->width(), item->height());
+}
+} else if (!autoArrange()) {
+item->dirty = false;
+}
+d->count++;
+d->dirty = true;
+}
+/*!
+This slot is used for a slightly-delayed update.
+The icon view is not redrawn immediately after inserting a new item
+but after a very small delay using a QTimer. This means that when
+many items are inserted in a loop the icon view is probably redrawn
+only once at the end of the loop. This makes the insertions both
+flicker-free and faster.
+*/
+void Q3IconView::slotUpdate()
+{
+d->updateTimer->stop();
+d->fullRedrawTimer->stop();
+if (!d->firstItem || !d->lastItem)
+return;
+// #### remove that ASA insertInGrid uses cached values and is efficient
+if (d->resortItemsWhenInsert)
+sort(d->sortDirection);
+else {
+int y = d->spacing;
+Q3IconViewItem *item = d->firstItem;
+int w = 0, h = 0;
+while (item) {
+bool changed;
+Q3IconViewItem *next = makeRowLayout(item, y, changed);
+if (!next || !next->next)
+break;
+if(!QApplication::reverseLayout())
+item = next;
+w = qMax(w, item->x() + item->width());
+h = qMax(h, item->y() + item->height());
+item = next;
+if (d->arrangement == LeftToRight)
+h = qMax(h, y);
+item = item->next;
+}
+if (d->lastItem && d->arrangement == TopToBottom) {
+item = d->lastItem;
+int x = item->x();
+while (item && item->x() >= x) {
+w = qMax(w, item->x() + item->width());
+h = qMax(h, item->y() + item->height());
+item = item->prev;
+}
+}
+w = qMax(qMax(d->cachedW, w), d->lastItem->x() + d->lastItem->width());
+h = qMax(qMax(d->cachedH, h), d->lastItem->y() + d->lastItem->height());
+if (d->arrangement == TopToBottom)
+w += d->spacing;
+else
+h += d->spacing;
+viewport()->setUpdatesEnabled(false);
+resizeContents(w, h);
+viewport()->setUpdatesEnabled(true);
+viewport()->repaint();
+}
+int cx = d->cachedContentsX == -1 ? contentsX() : d->cachedContentsX;
+int cy = d->cachedContentsY == -1 ? contentsY() : d->cachedContentsY;
+if (cx != contentsX() || cy != contentsY())
+setContentsPos(cx, cy);
+d->cachedContentsX = d->cachedContentsY = -1;
+d->cachedW = d->cachedH = 0;
+}
+/*!
+Takes the icon view item \a item out of the icon view and causes
+an update of the screen display. The item is not deleted. You
+should normally not need to call this function because
+Q3IconViewItem::~Q3IconViewItem() calls it. The normal way to delete
+an item is to delete it.
+*/
+void Q3IconView::takeItem(Q3IconViewItem *item)
+{
+if (!item)
+return;
+if (item->d->container1)
+item->d->container1->items.removeAll(item);
+if (item->d->container2)
+item->d->container2->items.removeAll(item);
+item->d->container2 = 0;
+item->d->container1 = 0;
+bool block = signalsBlocked();
+blockSignals(d->clearing);
+QRect r = item->rect();
+if (d->currentItem == item) {
+if (item->prev) {
+d->currentItem = item->prev;
+emit currentChanged(d->currentItem);
+repaintItem(d->currentItem);
+} else if (item->next) {
+d->currentItem = item->next;
+emit currentChanged(d->currentItem);
+repaintItem(d->currentItem);
+} else {
+d->currentItem = 0;
+emit currentChanged(d->currentItem);
+}
+}
+if (item->isSelected()) {
+item->selected = false;
+emit selectionChanged();
+}
+if (item == d->firstItem) {
+d->firstItem = d->firstItem->next;
+if (d->firstItem)
+d->firstItem->prev = 0;
+} else if (item == d->lastItem) {
+d->lastItem = d->lastItem->prev;
+if (d->lastItem)
+d->lastItem->next = 0;
+} else {
+Q3IconViewItem *i = item;
+if (i) {
+if (i->prev)
+i->prev->next = i->next;
+if (i->next)
+i->next->prev = i->prev;
+}
+}
+if (d->selectAnchor == item)
+d->selectAnchor = d->currentItem;
+if (!d->clearing)
+repaintContents(r.x(), r.y(), r.width(), r.height());
+item->view = 0;
+item->prev = 0;
+item->next = 0;
+d->count--;
+blockSignals(block);
+}
+/*!
+Returns the index of \a item, or -1 if \a item doesn't exist in
+this icon view.
+*/
+int Q3IconView::index(const Q3IconViewItem *item) const
+{
+if (!item)
+return -1;
+if (item == d->firstItem)
+return 0;
+else if (item == d->lastItem)
+return d->count - 1;
+else {
+Q3IconViewItem *i = d->firstItem;
+int j = 0;
+while (i && i != item) {
+i = i->next;
+++j;
+}
+return i ? j : -1;
+}
+}
+/*!
+Returns a pointer to the first item of the icon view, or 0 if
+there are no items in the icon view.
+\sa lastItem() currentItem()
+*/
+Q3IconViewItem *Q3IconView::firstItem() const
+{
+return d->firstItem;
+}
+/*!
+Returns a pointer to the last item of the icon view, or 0 if there
+are no items in the icon view.
+\sa firstItem() currentItem()
+*/
+Q3IconViewItem *Q3IconView::lastItem() const
+{
+return d->lastItem;
+}
+/*!
+Returns a pointer to the current item of the icon view, or 0 if no
+item is current.
+\sa setCurrentItem() firstItem() lastItem()
+*/
+Q3IconViewItem *Q3IconView::currentItem() const
+{
+return d->currentItem;
+}
+/*!
+\reimp
+*/
+QVariant Q3IconView::inputMethodQuery(Qt::InputMethodQuery query) const
+{
+if (query == Qt::ImMicroFocus) {
+return d->currentItem ? d->currentItem->rect() : QRect();
+}
+return QWidget::inputMethodQuery(query);
+}
+/*!
+Makes \a item the new current item of the icon view.
+*/
+void Q3IconView::setCurrentItem(Q3IconViewItem *item)
+{
+if (!item || item == d->currentItem)
+return;
+Q3IconViewItem *old = d->currentItem;
+d->currentItem = item;
+emit currentChanged(d->currentItem);
+if (d->selectionMode == Single) {
+bool changed = false;
+if (old && old->selected) {
+old->selected = false;
+changed = true;
+}
+if (item && !item->selected && item->isSelectable() && d->selectionMode != NoSelection) {
+item->selected = true;
+changed = true;
+emit selectionChanged(item);
+}
+if (changed)
+emit selectionChanged();
+}
+if (old)
+repaintItem(old);
+repaintItem(d->currentItem);
+}
+/*!
+Selects or unselects \a item depending on \a s, and may also
+unselect other items, depending on Q3IconView::selectionMode() and
+\a cb.
+If \a s is false, \a item is unselected.
+If \a s is true and Q3IconView::selectionMode() is \l Single, \a
+item is selected, and the item which was selected is unselected.
+If \a s is true and Q3IconView::selectionMode() is \l Extended, \a
+item is selected. If \a cb is true, the selection state of the
+icon view's other items is left unchanged. If \a cb is false (the
+default) all other items are unselected.
+If \a s is true and Q3IconView::selectionMode() is \l Multi \a item
+is selected.
+Note that \a cb is used only if Q3IconView::selectionMode() is \l
+Extended. \a cb defaults to false.
+All items whose selection status is changed repaint themselves.
+*/
+void Q3IconView::setSelected(Q3IconViewItem *item, bool s, bool cb)
+{
+if (!item)
+return;
+item->setSelected(s, cb);
+}
+/*!
+\property Q3IconView::count
+\brief the number of items in the icon view
+*/
+uint Q3IconView::count() const
+{
+return d->count;
+}
+/*!
+Performs autoscrolling when selecting multiple icons with the
+rubber band.
+*/
+void Q3IconView::doAutoScroll()
+{
+QRect oldRubber = QRect(*d->rubber);
+QPoint vp = viewport()->mapFromGlobal(QCursor::pos());
+QPoint pos = viewportToContents(vp);
+if (pos == d->rubber->bottomRight())
+return;
+d->rubber->setRight(pos.x());
+d->rubber->setBottom(pos.y());
+int minx = contentsWidth(), miny = contentsHeight();
+int maxx = 0, maxy = 0;
+bool changed = false;
+bool block = signalsBlocked();
+QRect rr;
+QRegion region(0, 0, visibleWidth(), visibleHeight());
+blockSignals(true);
+viewport()->setUpdatesEnabled(false);
+bool alreadyIntersected = false;
+QRect nr = d->rubber->normalized();
+QRect rubberUnion = nr.united(oldRubber.normalized());
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer;
+for (; c; c = c->n) {
+if (c->rect.intersects(rubberUnion)) {
+alreadyIntersected = true;
+for (int i = 0; i < c->items.size(); ++i) {
+Q3IconViewItem *item = c->items.at(i);
+if (d->selectedItems.contains(item))
+continue;
+if (!item->intersects(nr)) {
+if (item->isSelected()) {
+item->setSelected(false);
+changed = true;
+rr = rr.united(item->rect());
+}
+} else if (item->intersects(nr)) {
+if (!item->isSelected() && item->isSelectable()) {
+item->setSelected(true, true);
+changed = true;
+rr = rr.united(item->rect());
+} else {
+region = region.subtracted(QRect(contentsToViewport(item->pos()),
+item->size()));
+}
+minx = qMin(minx, item->x() - 1);
+miny = qMin(miny, item->y() - 1);
+maxx = qMax(maxx, item->x() + item->width() + 1);
+maxy = qMax(maxy, item->y() + item->height() + 1);
+}
+}
+} else {
+if (alreadyIntersected)
+break;
+}
+}
+viewport()->setUpdatesEnabled(true);
+blockSignals(block);
+QRect r = *d->rubber;
+*d->rubber = oldRubber;
+d->dragging = false;
+*d->rubber = r;
+if (changed) {
+d->drawAllBack = false;
+d->clipRegion = region;
+repaintContents(rr);
+d->drawAllBack = true;
+}
+ensureVisible(pos.x(), pos.y());
+d->dragging = true;
+if (changed) {
+emit selectionChanged();
+if (d->selectionMode == Single)
+emit selectionChanged(d->currentItem);
+}
+if (!QRect(50, 50, viewport()->width()-100, viewport()->height()-100).contains(vp) &&
+!d->scrollTimer) {
+d->scrollTimer = new QTimer(this);
+connect(d->scrollTimer, SIGNAL(timeout()),
+this, SLOT(doAutoScroll()));
+d->scrollTimer->start(100, false);
+} else if (QRect(50, 50, viewport()->width()-100, viewport()->height()-100).contains(vp) &&
+d->scrollTimer) {
+disconnect(d->scrollTimer, SIGNAL(timeout()),
+this, SLOT(doAutoScroll()));
+d->scrollTimer->stop();
+delete d->scrollTimer;
+d->scrollTimer = 0;
+}
+}
+/*!
+\reimp
+*/
+void Q3IconView::drawContents(QPainter *p, int cx, int cy, int cw, int ch)
+{
+if (d->dragging && d->rubber)
+drawRubber(p);
+QRect r = QRect(cx, cy, cw, ch);
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer;
+QRegion remaining(QRect(cx, cy, cw, ch));
+bool alreadyIntersected = false;
+while (c) {
+if (c->rect.intersects(r)) {
+p->save();
+p->resetXForm();
+QRect r2 = c->rect;
+r2 = r2.intersected(r);
+QRect r3(contentsToViewport(QPoint(r2.x(), r2.y())), QSize(r2.width(), r2.height()));
+if (d->drawAllBack) {
+p->setClipRect(r3);
+} else {
+QRegion reg = d->clipRegion.intersected(r3);
+p->setClipRegion(reg);
+}
+drawBackground(p, r3);
+remaining = remaining.subtracted(r3);
+p->restore();
+QPalette pal = palette();
+d->drawActiveSelection = hasFocus() || d->inMenuMode
+|| !style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this);
+if (!d->drawActiveSelection)
+pal.setCurrentColorGroup(QPalette::Inactive);
+// clip items to the container rect by default... this
+// prevents icons with alpha channels from being painted
+// twice when they are in 2 containers
+//
+// NOTE: the item could override this cliprect in its
+// paintItem() implementation, which makes this useless
+p->setClipRect(r2);
+for (int i = 0; i < c->items.size(); ++i) {
+Q3IconViewItem *item = c->items.at(i);
+if (item->rect().intersects(r) && !item->dirty) {
+p->save();
+p->setFont(font());
+item->paintItem(p, pal);
+p->restore();
+}
+}
+alreadyIntersected = true;
+} else {
+if (alreadyIntersected)
+break;
+}
+c = c->n;
+}
+if (!remaining.isEmpty()) {
+p->save();
+p->resetXForm();
+if (d->drawAllBack) {
+p->setClipRegion(remaining);
+} else {
+remaining = d->clipRegion.intersected(remaining);
+p->setClipRegion(remaining);
+}
+drawBackground(p, remaining.boundingRect());
+p->restore();
+}
+if ((hasFocus() || viewport()->hasFocus()) && d->currentItem &&
+d->currentItem->rect().intersects(r)) {
+d->currentItem->paintFocus(p, palette());
+}
+if (d->dragging && d->rubber)
+drawRubber(p);
+}
+/*!
+\overload
+Arranges all the items in the grid specified by gridX() and gridY().
+Even if sorting() is enabled, the items are not sorted by this
+function. If you want to sort or rearrange the items, use
+iconview->sort(iconview->sortDirection()).
+If \a update is true (the default), the viewport is repainted as
+well.
+\sa Q3IconView::setGridX(), Q3IconView::setGridY(), Q3IconView::sort()
+*/
+void Q3IconView::arrangeItemsInGrid(bool update)
+{
+if (!d->firstItem || !d->lastItem)
+return;
+d->containerUpdateLocked = true;
+int w = 0, h = 0, y = d->spacing;
+Q3IconViewItem *item = d->firstItem;
+bool changedLayout = false;
+while (item) {
+bool changed;
+Q3IconViewItem *next = makeRowLayout(item, y, changed);
+changedLayout = changed || changedLayout;
+if(!QApplication::reverseLayout())
+item = next;
+w = qMax(w, item->x() + item->width());
+h = qMax(h, item->y() + item->height());
+item = next;
+if (d->arrangement == LeftToRight)
+h = qMax(h, y);
+if (!item || !item->next)
+break;
+item = item->next;
+}
+if (d->lastItem && d->arrangement == TopToBottom) {
+item = d->lastItem;
+int x = item->x();
+while (item && item->x() >= x) {
+w = qMax(w, item->x() + item->width());
+h = qMax(h, item->y() + item->height());
+item = item->prev;
+}
+}
+d->containerUpdateLocked = false;
+w = qMax(qMax(d->cachedW, w), d->lastItem->x() + d->lastItem->width());
+h = qMax(qMax(d->cachedH, h), d->lastItem->y() + d->lastItem->height());
+if (d->arrangement == TopToBottom)
+w += d->spacing;
+else
+h += d->spacing;
+bool ue = updatesEnabled();
+if (ue)
+viewport()->setUpdatesEnabled(false);
+int vw = visibleWidth();
+int vh = visibleHeight();
+resizeContents(w, h);
+bool doAgain = false;
+if (d->arrangement == LeftToRight)
+doAgain = visibleWidth() != vw;
+if (d->arrangement == TopToBottom)
+doAgain = visibleHeight() != vh;
+if (doAgain) // in the case that the visibleExtend changed because of the resizeContents (scroll bar show/hide), redo layout again
+arrangeItemsInGrid(false);
+if (ue)
+viewport()->setUpdatesEnabled(true);
+d->dirty = !isVisible();
+rebuildContainers();
+if (update && (!optimize_layout || changedLayout))
+repaintContents(contentsX(), contentsY(), viewport()->width(), viewport()->height());
+}
+/*!
+This variant uses \a grid instead of (gridX(), gridY()). If \a
+grid is invalid (see QSize::isValid()), arrangeItemsInGrid()
+calculates a valid grid itself and uses that.
+If \a update is true (the default) the viewport is repainted.
+*/
+void Q3IconView::arrangeItemsInGrid(const QSize &grid, bool update)
+{
+d->containerUpdateLocked = true;
+QSize grid_(grid);
+if (!grid_.isValid()) {
+int w = 0, h = 0;
+Q3IconViewItem *item = d->firstItem;
+for (; item; item = item->next) {
+w = qMax(w, item->width());
+h = qMax(h, item->height());
+}
+grid_ = QSize(qMax(d->rastX + d->spacing, w),
+qMax(d->rastY + d->spacing, h));
+}
+int w = 0, h = 0;
+Q3IconViewItem *item = d->firstItem;
+for (; item; item = item->next) {
+int nx = item->x() / grid_.width();
+int ny = item->y() / grid_.height();
+item->move(nx * grid_.width(),
+ny * grid_.height());
+w = qMax(w, item->x() + item->width());
+h = qMax(h, item->y() + item->height());
+item->dirty = false;
+}
+d->containerUpdateLocked = false;
+resizeContents(w, h);
+rebuildContainers();
+if (update)
+repaintContents(contentsX(), contentsY(), viewport()->width(), viewport()->height());
+}
+/*!
+\reimp
+*/
+void Q3IconView::setContentsPos(int x, int y)
+{
+if (d->updateTimer->isActive()) {
+d->cachedContentsX = x;
+d->cachedContentsY = y;
+} else {
+d->cachedContentsY = d->cachedContentsX = -1;
+Q3ScrollView::setContentsPos(x, y);
+}
+}
+/*!
+\reimp
+*/
+void Q3IconView::showEvent(QShowEvent *)
+{
+if (d->dirty) {
+resizeContents(qMax(contentsWidth(), viewport()->width()),
+qMax(contentsHeight(), viewport()->height()));
+if (d->resortItemsWhenInsert)
+sort(d->sortDirection);
+if (autoArrange())
+arrangeItemsInGrid(false);
+}
+Q3ScrollView::show();
+}
+/*!
+\property Q3IconView::selectionMode
+\brief the selection mode of the icon view
+This can be \l Single (the default), \l Extended, \l Multi or \l
+NoSelection.
+*/
+void Q3IconView::setSelectionMode(SelectionMode m)
+{
+d->selectionMode = m;
+}
+Q3IconView::SelectionMode Q3IconView::selectionMode() const
+{
+return d->selectionMode;
+}
+/*!
+Returns a pointer to the item that contains point \a pos, which is
+given in contents coordinates, or 0 if no item contains point \a
+pos.
+*/
+Q3IconViewItem *Q3IconView::findItem(const QPoint &pos) const
+{
+if (!d->firstItem)
+return 0;
+Q3IconViewPrivate::ItemContainer *c = d->lastContainer;
+for (; c; c = c->p) {
+if (c->rect.contains(pos))
+for (int i = c->items.size()-1; i >= 0; --i)
+if (c->items.at(i)->contains(pos))
+return c->items.at(i);
+}
+return 0;
+}
+/*!
+\overload
+Returns a pointer to the first item whose text begins with \a
+text, or 0 if no such item could be found. Use the \a compare flag
+to control the comparison behavior.
+*/
+Q3IconViewItem *Q3IconView::findItem(const QString &text, ComparisonFlags compare) const
+{
+if (!d->firstItem)
+return 0;
+if (compare == CaseSensitive || compare == 0)
+compare |= ExactMatch;
+QString itmtxt;
+QString comtxt = text;
+if (! (compare & CaseSensitive))
+comtxt = text.toLower();
+Q3IconViewItem *item;
+if (d->currentItem)
+item = d->currentItem;
+else
+item = d->firstItem;
+Q3IconViewItem *beginsWithItem = 0;
+Q3IconViewItem *endsWithItem = 0;
+Q3IconViewItem *containsItem = 0;
+if (item) {
+for (; item; item = item->next) {
+if (!(compare & CaseSensitive))
+itmtxt = item->text().toLower();
+else
+itmtxt = item->text();
+if ((compare & ExactMatch)==ExactMatch && itmtxt == comtxt)
+return item;
+if (compare & BeginsWith && !beginsWithItem && itmtxt.startsWith(comtxt))
+beginsWithItem = containsItem = item;
+if (compare & EndsWith && !endsWithItem && itmtxt.endsWith(comtxt))
+endsWithItem = containsItem = item;
+if ((compare & ExactMatch)==0 && !containsItem && itmtxt.contains(comtxt))
+containsItem = item;
+}
+if (d->currentItem && d->firstItem) {
+item = d->firstItem;
+for (; item && item != d->currentItem; item = item->next) {
+if (!(compare & CaseSensitive))
+itmtxt = item->text().toLower();
+else
+itmtxt = item->text();
+if ((compare & ExactMatch)==ExactMatch && itmtxt == comtxt)
+return item;
+if (compare & BeginsWith && !beginsWithItem && itmtxt.startsWith(comtxt))
+beginsWithItem = containsItem = item;
+if (compare & EndsWith && !endsWithItem && itmtxt.endsWith(comtxt))
+endsWithItem = containsItem = item;
+if ((compare & ExactMatch)==0 && !containsItem && itmtxt.contains(comtxt))
+containsItem = item;
+}
+}
+}
+// Obey the priorities
+if (beginsWithItem)
+return beginsWithItem;
+else if (endsWithItem)
+return endsWithItem;
+else if (containsItem)
+return containsItem;
+return 0;
+}
+/*!
+Unselects all the items.
+*/
+void Q3IconView::clearSelection()
+{
+selectAll(false);
+}
+/*!
+In Multi and Extended modes, this function sets all items to be
+selected if \a select is true, and to be unselected if \a select
+is false.
+In Single and NoSelection modes, this function only changes the
+selection status of currentItem().
+*/
+void Q3IconView::selectAll(bool select)
+{
+if (d->selectionMode == NoSelection)
+return;
+if (d->selectionMode == Single) {
+if (d->currentItem)
+d->currentItem->setSelected(select);
+return;
+}
+bool b = signalsBlocked();
+blockSignals(true);
+Q3IconViewItem *item = d->firstItem;
+Q3IconViewItem *i = d->currentItem;
+bool changed = false;
+bool ue = viewport()->updatesEnabled();
+if (ue)
+viewport()->setUpdatesEnabled(false);
+QRect rr;
+for (; item; item = item->next) {
+if (select != item->isSelected()) {
+item->setSelected(select, true);
+rr = rr.united(item->rect());
+changed = true;
+}
+}
+if (ue)
+viewport()->setUpdatesEnabled(true);
+// we call updateContents not repaintContents because of possible previous updateContents
+Q3ScrollView::updateContents(rr);
+QApplication::sendPostedEvents(viewport(), QEvent::Paint);
+if (i)
+setCurrentItem(i);
+blockSignals(b);
+if (changed) {
+emit selectionChanged();
+}
+}
+/*!
+Inverts the selection. Works only in Multi and Extended selection
+mode.
+*/
+void Q3IconView::invertSelection()
+{
+if (d->selectionMode == Single ||
+d->selectionMode == NoSelection)
+return;
+bool b = signalsBlocked();
+blockSignals(true);
+Q3IconViewItem *item = d->firstItem;
+for (; item; item = item->next)
+item->setSelected(!item->isSelected(), true);
+blockSignals(b);
+emit selectionChanged();
+}
+/*!
+Repaints the \a item.
+*/
+void Q3IconView::repaintItem(Q3IconViewItem *item)
+{
+if (!item || item->dirty)
+return;
+if (QRect(contentsX(), contentsY(), visibleWidth(), visibleHeight()).
+intersects(QRect(item->x() - 1, item->y() - 1, item->width() + 2, item->height() + 2)))
+repaintContents(item->x() - 1, item->y() - 1, item->width() + 2, item->height() + 2);
+}
+/*!
+Repaints the selected items.
+*/
+void Q3IconView::repaintSelectedItems()
+{
+if (selectionMode() == NoSelection)
+return;
+if (selectionMode() == Single) {
+if (!currentItem() || !currentItem()->isSelected())
+return;
+QRect itemRect = currentItem()->rect(); //rect in contents coordinates
+itemRect.moveBy(-contentsX(), -contentsY());
+viewport()->update(itemRect);
+} else {
+// check if any selected items are visible
+Q3IconViewItem *item = firstItem();
+const QRect vr = QRect(contentsX(), contentsY(), visibleWidth(), visibleHeight());
+while (item) {
+if (item->isSelected() && item->rect().intersects(vr))
+repaintItem(item);
+item = item->nextItem();
+}
+}
+}
+/*!
+Makes sure that \a item is entirely visible. If necessary,
+ensureItemVisible() scrolls the icon view.
+\sa ensureVisible()
+*/
+void Q3IconView::ensureItemVisible(Q3IconViewItem *item)
+{
+if (!item)
+return;
+if ((d->updateTimer && d->updateTimer->isActive())
+|| (d->fullRedrawTimer && d->fullRedrawTimer->isActive()))
+slotUpdate();
+int w = item->width();
+int h = item->height();
+ensureVisible(item->x() + w / 2, item->y() + h / 2,
+w / 2 + 1, h / 2 + 1);
+}
+/*!
+Finds the first item whose bounding rectangle overlaps \a r and
+returns a pointer to that item. \a r is given in content
+coordinates. Returns 0 if no item overlaps \a r.
+If you want to find all items that touch \a r, you will need to
+use this function and nextItem() in a loop ending at
+findLastVisibleItem() and test Q3IconViewItem::rect() for each of
+these items.
+\sa findLastVisibleItem() Q3IconViewItem::rect()
+*/
+Q3IconViewItem* Q3IconView::findFirstVisibleItem(const QRect &r) const
+{
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer;
+Q3IconViewItem *i = 0;
+bool alreadyIntersected = false;
+for (; c; c = c->n) {
+if (c->rect.intersects(r)) {
+alreadyIntersected = true;
+for (int j = 0; j < c->items.size(); ++j) {
+Q3IconViewItem *item = c->items.at(j);
+if (r.intersects(item->rect())) {
+if (!i) {
+i = item;
+} else {
+QRect r2 = item->rect();
+QRect r3 = i->rect();
+if (r2.y() < r3.y())
+i = item;
+else if (r2.y() == r3.y() &&
+r2.x() < r3.x())
+i = item;
+}
+}
+}
+} else {
+if (alreadyIntersected)
+break;
+}
+}
+return i;
+}
+/*!
+Finds the last item whose bounding rectangle overlaps \a r and
+returns a pointer to that item. \a r is given in content
+coordinates. Returns 0 if no item overlaps \a r.
+\sa findFirstVisibleItem()
+*/
+Q3IconViewItem* Q3IconView::findLastVisibleItem(const QRect &r) const
+{
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer;
+Q3IconViewItem *i = 0;
+bool alreadyIntersected = false;
+for (; c; c = c->n) {
+if (c->rect.intersects(r)) {
+alreadyIntersected = true;
+for (int j = 0; j < c->items.size(); ++j) {
+Q3IconViewItem *item = c->items.at(j);
+if (r.intersects(item->rect())) {
+if (!i) {
+i = item;
+} else {
+QRect r2 = item->rect();
+QRect r3 = i->rect();
+if (r2.y() > r3.y())
+i = item;
+else if (r2.y() == r3.y() &&
+r2.x() > r3.x())
+i = item;
+}
+}
+}
+} else {
+if (alreadyIntersected)
+break;
+}
+}
+return i;
+}
+/*!
+Clears the icon view. All items are deleted.
+*/
+void Q3IconView::clear()
+{
+setContentsPos(0, 0);
+d->clearing = true;
+bool block = signalsBlocked();
+blockSignals(true);
+clearSelection();
+blockSignals(block);
+setContentsPos(0, 0);
+d->currentItem = 0;
+if (!d->firstItem) {
+d->clearing = false;
+return;
+}
+Q3IconViewItem *item = d->firstItem, *tmp;
+d->firstItem = 0;
+while (item) {
+tmp = item->next;
+delete item;
+item = tmp;
+}
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer, *tmpc;
+while (c) {
+tmpc = c->n;
+delete c;
+c = tmpc;
+}
+d->firstContainer = d->lastContainer = 0;
+d->count = 0;
+d->lastItem = 0;
+setCurrentItem(0);
+d->highlightedItem = 0;
+d->tmpCurrentItem = 0;
+d->drawDragShapes = false;
+resizeContents(0, 0);
+// maybe we don't need this update, so delay it
+d->fullRedrawTimer->start(0, true);
+d->cleared = true;
+d->clearing = false;
+}
+/*!
+\property Q3IconView::gridX
+\brief the horizontal grid  of the icon view
+If the value is -1, (the default), Q3IconView computes suitable
+column widths based on the icon view's contents.
+Note that setting a grid width overrides setMaxItemWidth().
+*/
+void Q3IconView::setGridX(int rx)
+{
+d->rastX = rx >= 0 ? rx : -1;
+}
+/*!
+\property Q3IconView::gridY
+\brief the vertical grid  of the icon view
+If the value is -1, (the default), Q3IconView computes suitable
+column heights based on the icon view's contents.
+*/
+void Q3IconView::setGridY(int ry)
+{
+d->rastY = ry >= 0 ? ry : -1;
+}
+int Q3IconView::gridX() const
+{
+return d->rastX;
+}
+int Q3IconView::gridY() const
+{
+return d->rastY;
+}
+/*!
+\property Q3IconView::spacing
+\brief the space in pixels between icon view items
+The default is 5 pixels.
+Negative values for spacing are illegal.
+*/
+void Q3IconView::setSpacing(int sp)
+{
+d->spacing = sp;
+}
+int Q3IconView::spacing() const
+{
+return d->spacing;
+}
+/*!
+\property Q3IconView::itemTextPos
+\brief the position where the text of each item is drawn.
+Valid values are \l Bottom or \l Right. The default is \l Bottom.
+*/
+void Q3IconView::setItemTextPos(ItemTextPos pos)
+{
+if (pos == d->itemTextPos || (pos != Bottom && pos != Right))
+return;
+d->itemTextPos = pos;
+Q3IconViewItem *item = d->firstItem;
+for (; item; item = item->next) {
+item->wordWrapDirty = true;
+item->calcRect();
+}
+arrangeItemsInGrid(true);
+}
+Q3IconView::ItemTextPos Q3IconView::itemTextPos() const
+{
+return d->itemTextPos;
+}
+/*!
+\property Q3IconView::itemTextBackground
+\brief the brush to use when drawing the background of an item's text.
+By default this brush is set to Qt::NoBrush, meaning that only the
+normal icon view background is used.
+*/
+void Q3IconView::setItemTextBackground(const QBrush &brush)
+{
+d->itemTextBrush = brush;
+}
+QBrush Q3IconView::itemTextBackground() const
+{
+return d->itemTextBrush;
+}
+/*!
+\property Q3IconView::arrangement
+\brief the arrangement mode of the icon view
+This can be \l LeftToRight or \l TopToBottom. The default is \l
+LeftToRight.
+*/
+void Q3IconView::setArrangement(Arrangement am)
+{
+if (d->arrangement == am)
+return;
+d->arrangement = am;
+viewport()->setUpdatesEnabled(false);
+resizeContents(viewport()->width(), viewport()->height());
+viewport()->setUpdatesEnabled(true);
+arrangeItemsInGrid(true);
+}
+Q3IconView::Arrangement Q3IconView::arrangement() const
+{
+return d->arrangement;
+}
+/*!
+\property Q3IconView::resizeMode
+\brief the resize mode of the icon view
+This can be \l Fixed or \l Adjust. The default is \l Fixed.
+See \l ResizeMode.
+*/
+void Q3IconView::setResizeMode(ResizeMode rm)
+{
+if (d->resizeMode == rm)
+return;
+d->resizeMode = rm;
+}
+Q3IconView::ResizeMode Q3IconView::resizeMode() const
+{
+return d->resizeMode;
+}
+/*!
+\property Q3IconView::maxItemWidth
+\brief the maximum width that an item may have.
+The default is 100 pixels.
+Note that if the gridX() value is set Q3IconView will ignore
+this property.
+*/
+void Q3IconView::setMaxItemWidth(int w)
+{
+d->maxItemWidth = w;
+}
+/*!
+\property Q3IconView::maxItemTextLength
+\brief the maximum length (in characters) that an item's text may have.
+The default is 255 characters.
+*/
+void Q3IconView::setMaxItemTextLength(int w)
+{
+d->maxItemTextLength = w;
+}
+int Q3IconView::maxItemWidth() const
+{
+if (d->rastX != -1)
+return d->rastX - 2;
+else
+return d->maxItemWidth;
+}
+int Q3IconView::maxItemTextLength() const
+{
+return d->maxItemTextLength;
+}
+/*!
+\property Q3IconView::itemsMovable
+\brief whether the user is allowed to move items around in the icon view
+The default is true.
+*/
+void Q3IconView::setItemsMovable(bool b)
+{
+d->rearrangeEnabled = b;
+}
+bool Q3IconView::itemsMovable() const
+{
+return d->rearrangeEnabled;
+}
+/*!
+\property Q3IconView::autoArrange
+\brief whether the icon view rearranges its items when a new item is inserted.
+The default is true.
+Note that if the icon view is not visible at the time of
+insertion, Q3IconView defers all position-related work until it is
+shown and then calls arrangeItemsInGrid().
+*/
+void Q3IconView::setAutoArrange(bool b)
+{
+d->reorderItemsWhenInsert = b;
+}
+bool Q3IconView::autoArrange() const
+{
+return d->reorderItemsWhenInsert;
+}
+/*!
+If \a sort is true, this function sets the icon view to sort items
+when a new item is inserted. If \a sort is false, the icon view
+will not be sorted.
+Note that autoArrange() must be true for sorting to take place.
+If \a ascending is true (the default), items are sorted in
+ascending order. If \a ascending is false, items are sorted in
+descending order.
+Q3IconViewItem::compare() is used to compare pairs of items. The
+sorting is based on the items' keys; these default to the items'
+text unless specifically set to something else.
+\sa Q3IconView::setAutoArrange(), Q3IconView::autoArrange(),
+sortDirection(), sort(), Q3IconViewItem::setKey()
+*/
+void Q3IconView::setSorting(bool sort, bool ascending)
+{
+d->resortItemsWhenInsert = sort;
+d->sortDirection = ascending;
+}
+/*!
+\property Q3IconView::sorting
+\brief whether the icon view sorts on insertion
+The default is false, i.e. no sorting on insertion.
+To set the sorting, use setSorting().
+*/
+bool Q3IconView::sorting() const
+{
+return d->resortItemsWhenInsert;
+}
+/*!
+\property Q3IconView::sortDirection
+\brief whether the sort direction for inserting new items is ascending;
+The default is true (i.e. ascending). This sort direction is only
+meaningful if both sorting() and autoArrange() are true.
+To set the sort direction, use setSorting()
+*/
+bool Q3IconView::sortDirection() const
+{
+return d->sortDirection;
+}
+/*!
+\property Q3IconView::wordWrapIconText
+\brief whether the item text will be word-wrapped if it is too long
+The default is true.
+If this property is false, icon text that is too long is
+truncated, and an ellipsis (...) appended to indicate that
+truncation has occurred. The full text can still be seen by the
+user if they hover the mouse because the full text is shown in a
+tooltip; see setShowToolTips().
+*/
+void Q3IconView::setWordWrapIconText(bool b)
+{
+if (d->wordWrapIconText == (uint)b)
+return;
+d->wordWrapIconText = b;
+for (Q3IconViewItem *item = d->firstItem; item; item = item->next) {
+item->wordWrapDirty = true;
+item->calcRect();
+}
+arrangeItemsInGrid(true);
+}
+bool Q3IconView::wordWrapIconText() const
+{
+return d->wordWrapIconText;
+}
+/*!
+\property Q3IconView::showToolTips
+\brief whether the icon view will display a tool tip with the complete text for any truncated item text
+The default is true. Note that this has no effect if
+setWordWrapIconText() is true, as it is by default.
+*/
+void Q3IconView::setShowToolTips(bool b)
+{
+d->showTips = b;
+}
+bool Q3IconView::showToolTips() const
+{
+return d->showTips;
+}
+/*!
+\reimp
+*/
+void Q3IconView::contentsMousePressEvent(QMouseEvent *e)
+{
+contentsMousePressEventEx(e);
+}
+void Q3IconView::contentsMousePressEventEx(QMouseEvent *e)
+{
+if (d->rubber) {
+d->dragging = false;
+delete d->rubber;
+d->rubber = 0;
+viewport()->update();
+if (d->scrollTimer) {
+disconnect(d->scrollTimer, SIGNAL(timeout()), this, SLOT(doAutoScroll()));
+d->scrollTimer->stop();
+delete d->scrollTimer;
+d->scrollTimer = 0;
+}
+}
+d->dragStartPos = e->pos();
+Q3IconViewItem *item = findItem(e->pos());
+d->pressedItem = item;
+if (item)
+d->selectAnchor = item;
+#ifndef QT_NO_TEXTEDIT
+if (d->renamingItem)
+d->renamingItem->renameItem();
+#endif
+if (!d->currentItem && !item && d->firstItem) {
+d->currentItem = d->firstItem;
+repaintItem(d->firstItem);
+}
+if (item && item->dragEnabled())
+d->startDragItem = item;
+else
+d->startDragItem = 0;
+if (e->button() == Qt::LeftButton && !(e->state() & Qt::ShiftButton) &&
+!(e->state() & Qt::ControlButton) && item && item->isSelected() &&
+item->textRect(false).contains(e->pos())) {
+if (!item->renameEnabled()) {
+d->mousePressed = true;
+#ifndef QT_NO_TEXTEDIT
+} else {
+ensureItemVisible(item);
+setCurrentItem(item);
+item->rename();
+goto emit_signals;
+#endif
+}
+}
+d->pressedSelected = item && item->isSelected();
+if (item && item->isSelectable()) {
+if (d->selectionMode == Single)
+item->setSelected(true, e->state() & Qt::ControlButton);
+else if (d->selectionMode == Multi && !item->isSelected())
+item->setSelected(true, e->state() & Qt::ControlButton);
+else if (d->selectionMode == Extended) {
+if (e->state() & Qt::ShiftButton) {
+d->pressedSelected = false;
+bool block = signalsBlocked();
+blockSignals(true);
+viewport()->setUpdatesEnabled(false);
+QRect r;
+bool select = true;
+if (d->currentItem)
+r = QRect(qMin(d->currentItem->x(), item->x()),
+qMin(d->currentItem->y(), item->y()),
+0, 0);
+else
+r = QRect(0, 0, 0, 0);
+if (d->currentItem) {
+if (d->currentItem->x() < item->x())
+r.setWidth(item->x() - d->currentItem->x() + item->width());
+else
+r.setWidth(d->currentItem->x() - item->x() + d->currentItem->width());
+if (d->currentItem->y() < item->y())
+r.setHeight(item->y() - d->currentItem->y() + item->height());
+else
+r.setHeight(d->currentItem->y() - item->y() + d->currentItem->height());
+r = r.normalized();
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer;
+bool alreadyIntersected = false;
+QRect redraw;
+for (; c; c = c->n) {
+if (c->rect.intersects(r)) {
+alreadyIntersected = true;
+for (int i = 0; i < c->items.size(); ++i) {
+Q3IconViewItem *item = c->items.at(i);
+if (r.intersects(item->rect())) {
+redraw = redraw.united(item->rect());
+item->setSelected(select, true);
+}
+}
+} else {
+if (alreadyIntersected)
+break;
+}
+}
+redraw = redraw.united(item->rect());
+viewport()->setUpdatesEnabled(true);
+repaintContents(redraw);
+}
+blockSignals(block);
+viewport()->setUpdatesEnabled(true);
+item->setSelected(select, true);
+emit selectionChanged();
+} else if (e->state() & Qt::ControlButton) {
+d->pressedSelected = false;
+item->setSelected(!item->isSelected(), e->state() & Qt::ControlButton);
+} else {
+item->setSelected(true, e->state() & Qt::ControlButton);
+}
+}
+} else if ((d->selectionMode != Single || e->button() == Qt::RightButton)
+&& !(e->state() & Qt::ControlButton))
+selectAll(false);
+setCurrentItem(item);
+if (e->button() == Qt::LeftButton) {
+if (!item && (d->selectionMode == Multi ||
+d->selectionMode == Extended)) {
+d->tmpCurrentItem = d->currentItem;
+d->currentItem = 0;
+repaintItem(d->tmpCurrentItem);
+if (d->rubber)
+delete d->rubber;
+d->rubber = 0;
+d->rubber = new QRect(e->x(), e->y(), 0, 0);
+d->selectedItems.clear();
+if ((e->state() & Qt::ControlButton) == Qt::ControlButton) {
+for (Q3IconViewItem *i = firstItem(); i; i = i->nextItem())
+if (i->isSelected())
+d->selectedItems.insert(i, i);
+}
+}
+d->mousePressed = true;
+}
+emit_signals:
+if (!d->rubber) {
+emit mouseButtonPressed(e->button(), item, e->globalPos());
+emit pressed(item);
+emit pressed(item, e->globalPos());
+if (e->button() == Qt::RightButton)
+emit rightButtonPressed(item, e->globalPos());
+}
+}
+/*!
+\reimp
+*/
+void Q3IconView::contentsContextMenuEvent(QContextMenuEvent *e)
+{
+if (!receivers(SIGNAL(contextMenuRequested(Q3IconViewItem*,QPoint)))) {
+e->ignore();
+return;
+}
+if (e->reason() == QContextMenuEvent::Keyboard) {
+Q3IconViewItem *item = currentItem();
+QRect r = item ? item->rect() : QRect(0, 0, visibleWidth(), visibleHeight());
+emit contextMenuRequested(item, viewport()->mapToGlobal(contentsToViewport(r.center())));
+} else {
+d->mousePressed = false;
+Q3IconViewItem *item = findItem(e->pos());
+emit contextMenuRequested(item, e->globalPos());
+}
+}
+/*!
+\reimp
+*/
+void Q3IconView::contentsMouseReleaseEvent(QMouseEvent *e)
+{
+Q3IconViewItem *item = findItem(e->pos());
+d->selectedItems.clear();
+bool emitClicked = true;
+d->mousePressed = false;
+d->startDragItem = 0;
+if (d->rubber) {
+d->dragging = false;
+viewport()->update();
+if ((d->rubber->topLeft() - d->rubber->bottomRight()).manhattanLength() >
+QApplication::startDragDistance())
+emitClicked = false;
+delete d->rubber;
+d->rubber = 0;
+d->currentItem = d->tmpCurrentItem;
+d->tmpCurrentItem = 0;
+if (d->currentItem)
+repaintItem(d->currentItem);
+}
+if (d->scrollTimer) {
+disconnect(d->scrollTimer, SIGNAL(timeout()), this, SLOT(doAutoScroll()));
+d->scrollTimer->stop();
+delete d->scrollTimer;
+d->scrollTimer = 0;
+}
+if ((d->selectionMode == Extended || d->selectionMode == Multi) &&
+d->currentItem == d->pressedItem &&
+d->pressedSelected && d->currentItem) {
+if (d->selectionMode == Extended) {
+bool block = signalsBlocked();
+blockSignals(true);
+clearSelection();
+blockSignals(block);
+}
+if (d->currentItem->isSelectable()) {
+d->currentItem->selected = (d->selectionMode == Extended);
+repaintItem(d->currentItem);
+}
+emit selectionChanged();
+}
+d->pressedItem = 0;
+if (emitClicked) {
+emit mouseButtonClicked(e->button(), item, e->globalPos());
+emit clicked(item);
+emit clicked(item, e->globalPos());
+if (e->button() == Qt::RightButton)
+emit rightButtonClicked(item, e->globalPos());
+}
+}
+/*!
+\reimp
+*/
+void Q3IconView::contentsMouseMoveEvent(QMouseEvent *e)
+{
+Q3IconViewItem *item = findItem(e->pos());
+if (d->highlightedItem != item) {
+if (item)
+emit onItem(item);
+else
+emit onViewport();
+d->highlightedItem = item;
+}
+if (d->mousePressed && e->state() == Qt::NoButton)
+d->mousePressed = false;
+if (d->startDragItem)
+item = d->startDragItem;
+if (d->mousePressed && d->startDragItem && item && item == d->currentItem &&
+(item->isSelected() || d->selectionMode == NoSelection) && item->dragEnabled()) {
+if ((d->dragStartPos - e->pos()).manhattanLength() > QApplication::startDragDistance()) {
+d->mousePressed = false;
+d->cleared = false;
+#ifndef QT_NO_DRAGANDDROP
+startDrag();
+#endif
+if (d->tmpCurrentItem)
+repaintItem(d->tmpCurrentItem);
+}
+} else if (d->mousePressed && !d->currentItem && d->rubber) {
+doAutoScroll();
+}
+}
+/*!
+\reimp
+*/
+void Q3IconView::contentsMouseDoubleClickEvent(QMouseEvent *e)
+{
+Q3IconViewItem *item = findItem(e->pos());
+if (item) {
+selectAll(false);
+item->setSelected(true, true);
+emit doubleClicked(item);
+}
+}
+/*!
+\reimp
+*/
+#ifndef QT_NO_DRAGANDDROP
+void Q3IconView::contentsDragEnterEvent(QDragEnterEvent *e)
+{
+d->dragging = true;
+d->drawDragShapes = true;
+d->tmpCurrentItem = 0;
+initDragEnter(e);
+d->oldDragPos = e->pos();
+d->oldDragAcceptAction = false;
+drawDragShapes(e->pos());
+d->dropped = false;
+e->accept();
+}
+/*!
+\reimp
+*/
+void Q3IconView::contentsDragMoveEvent(QDragMoveEvent *e)
+{
+if (e->pos() == d->oldDragPos) {
+if (d->oldDragAcceptAction)
+e->acceptAction();
+else
+e->ignore();
+return;
+}
+drawDragShapes(d->oldDragPos);
+d->dragging = false;
+Q3IconViewItem *old = d->tmpCurrentItem;
+d->tmpCurrentItem = 0;
+Q3IconViewItem *item = findItem(e->pos());
+if (item) {
+if (old &&
+old->rect().contains(d->oldDragPos) &&
+!old->rect().contains(e->pos())) {
+old->dragLeft();
+repaintItem(old);
+}
+if (!item->rect().contains(d->oldDragPos))
+item->dragEntered();
+if (item->acceptDrop(e) || (item->isSelected() && e->source() == viewport())) {
+d->oldDragAcceptAction = true;
+e->acceptAction();
+} else {
+d->oldDragAcceptAction = false;
+e->ignore();
+}
+d->tmpCurrentItem = item;
+viewport()->update();
+} else {
+e->acceptAction();
+d->oldDragAcceptAction = true;
+if (old) {
+old->dragLeft();
+repaintItem(old);
+}
+}
+d->oldDragPos = e->pos();
+drawDragShapes(e->pos());
+d->dragging = true;
+}
+/*!
+\reimp
+*/
+void Q3IconView::contentsDragLeaveEvent(QDragLeaveEvent *)
+{
+if (!d->dropped)
+drawDragShapes(d->oldDragPos);
+d->dragging = false;
+if (d->tmpCurrentItem) {
+repaintItem(d->tmpCurrentItem);
+d->tmpCurrentItem->dragLeft();
+}
+d->tmpCurrentItem = 0;
+d->isIconDrag = false;
+d->iconDragData.clear();
+}
+/*!
+\reimp
+*/
+void Q3IconView::contentsDropEvent(QDropEvent *e)
+{
+d->dropped = true;
+d->dragging = false;
+drawDragShapes(d->oldDragPos);
+if (d->tmpCurrentItem)
+repaintItem(d->tmpCurrentItem);
+Q3IconViewItem *i = findItem(e->pos());
+if ((!i || i->isSelected()) && e->source() == viewport() && d->currentItem && !d->cleared) {
+if (!d->rearrangeEnabled)
+return;
+QRect r = d->currentItem->rect();
+d->currentItem->move(e->pos() - d->dragStart);
+int w = d->currentItem->x() + d->currentItem->width() + 1;
+int h = d->currentItem->y() + d->currentItem->height() + 1;
+repaintItem(d->currentItem);
+repaintContents(r.x(), r.y(), r.width(), r.height());
+int dx = d->currentItem->x() - r.x();
+int dy = d->currentItem->y() - r.y();
+Q3IconViewItem *item = d->firstItem;
+QRect rr;
+for (; item; item = item->next) {
+if (item->isSelected() && item != d->currentItem) {
+rr = rr.united(item->rect());
+item->moveBy(dx, dy);
+rr = rr.united(item->rect());
+}
+w = qMax(w, item->x() + item->width() + 1);
+h = qMax(h, item->y() + item->height() + 1);
+}
+repaintContents(rr);
+bool fullRepaint = false;
+if (w > contentsWidth() ||
+h > contentsHeight())
+fullRepaint = true;
+int oldw = contentsWidth();
+int oldh = contentsHeight();
+resizeContents(w, h);
+if (fullRepaint) {
+repaintContents(oldw, 0, contentsWidth() - oldw, contentsHeight());
+repaintContents(0, oldh, contentsWidth(), contentsHeight() - oldh);
+}
+e->acceptAction();
+} else if (!i && (e->source() != viewport() || d->cleared)) {
+QLinkedList<Q3IconDragItem> lst;
+if (Q3IconDrag::canDecode(e)) {
+QLinkedList<Q3IconDragDataItem> l;
+Q3IconDragPrivate::decode(e, l);
+QLinkedList<Q3IconDragDataItem>::Iterator it = l.begin();
+for (; it != l.end(); ++it)
+lst << (*it).data;
+}
+emit dropped(e, lst);
+} else if (i) {
+QLinkedList<Q3IconDragItem> lst;
+if (Q3IconDrag::canDecode(e)) {
+QLinkedList<Q3IconDragDataItem> l;
+Q3IconDragPrivate::decode(e, l);
+QLinkedList<Q3IconDragDataItem>::Iterator it = l.begin();
+for (; it != l.end(); ++it)
+lst << (*it).data;
+}
+i->dropped(e, lst);
+}
+d->isIconDrag = false;
+}
+#endif
+/*!
+\reimp
+*/
+void Q3IconView::resizeEvent(QResizeEvent* e)
+{
+Q3ScrollView::resizeEvent(e);
+if (d->resizeMode == Adjust) {
+optimize_layout = true;
+adjustItems();
+optimize_layout = false;
+#if 0 // no need for timer delay anymore
+d->oldSize = e->oldSize();
+if (d->adjustTimer->isActive())
+d->adjustTimer->stop();
+d->adjustTimer->start(0, true);
+#endif
+}
+}
+/*!
+Adjusts the positions of the items to the geometry of the icon
+view.
+*/
+void Q3IconView::adjustItems()
+{
+d->adjustTimer->stop();
+if (d->resizeMode == Adjust)
+arrangeItemsInGrid(true);
+}
+/*!
+\reimp
+*/
+void Q3IconView::keyPressEvent(QKeyEvent *e)
+{
+if (!d->firstItem)
+return;
+if (!d->currentItem) {
+setCurrentItem(d->firstItem);
+if (d->selectionMode == Single)
+d->currentItem->setSelected(true, true);
+return;
+}
+bool selectCurrent = true;
+switch (e->key()) {
+case Qt::Key_Escape:
+e->ignore();
+break;
+#ifndef QT_NO_TEXTEDIT
+case Qt::Key_F2: {
+if (d->currentItem->renameEnabled()) {
+d->currentItem->renameItem();
+d->currentItem->rename();
+return;
+}
+} break;
+#endif
+case Qt::Key_Home: {
+d->currInputString.clear();
+if (!d->firstItem)
+break;
+selectCurrent = false;
+Q3IconViewItem *item = 0;
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer;
+while (!item && c) {
+QList<Q3IconViewItem*> &list = c->items;
+for (int j = 0; j < list.size(); ++j) {
+Q3IconViewItem *i = list.at(j);
+if (!item) {
+item = i;
+} else {
+if (d->arrangement == LeftToRight) {
+// we use pixmap so the items textlength are ignored
+// find topmost, leftmost item
+if (i->pixmapRect(false).y() < item->pixmapRect(false).y() ||
+(i->pixmapRect(false).y() == item->pixmapRect(false).y() &&
+i->pixmapRect(false).x() < item->pixmapRect(false).x()))
+item = i;
+} else {
+// find leftmost, topmost item
+if (i->pixmapRect(false).x() < item->pixmapRect(false).x() ||
+(i->pixmapRect(false).x() == item->pixmapRect(false).x() &&
+i->pixmapRect(false).y() < item->pixmapRect(false).y()))
+item = i;
+}
+}
+}
+c = c->n;
+}
+if (item) {
+Q3IconViewItem *old = d->currentItem;
+setCurrentItem(item);
+ensureItemVisible(item);
+handleItemChange(old, e->state() & Qt::ShiftButton,
+e->state() & Qt::ControlButton, true);
+}
+} break;
+case Qt::Key_End: {
+d->currInputString.clear();
+if (!d->lastItem)
+break;
+selectCurrent = false;
+Q3IconViewItem *item = 0;
+Q3IconViewPrivate::ItemContainer *c = d->lastContainer;
+while (!item && c) {
+QList<Q3IconViewItem*> &list = c->items;
+for (int j = 0; j < list.size(); ++j) {
+Q3IconViewItem *i = list.at(j);
+if (!item) {
+item = i;
+} else {
+if (d->arrangement == LeftToRight) {
+// find bottommost, rightmost item
+if (i->pixmapRect(false).bottom() > item->pixmapRect(false).bottom() ||
+(i->pixmapRect(false).bottom() == item->pixmapRect(false).bottom() &&
+i->pixmapRect(false).right() > item->pixmapRect(false).right()))
+item = i;
+} else {
+// find rightmost, bottommost item
+if (i->pixmapRect(false).right() > item->pixmapRect(false).right() ||
+(i->pixmapRect(false).right() == item->pixmapRect(false).right() &&
+i->pixmapRect(false).bottom() > item->pixmapRect(false).bottom()))
+item = i;
+}
+}
+}
+c = c->p;
+}
+if (item) {
+Q3IconViewItem *old = d->currentItem;
+setCurrentItem(item);
+ensureItemVisible(item);
+handleItemChange(old, e->state() & Qt::ShiftButton,
+e->state() & Qt::ControlButton, true);
+}
+} break;
+case Qt::Key_Right: {
+d->currInputString.clear();
+Q3IconViewItem *item;
+selectCurrent = false;
+Direction dir = DirRight;
+QRect r(0, d->currentItem->y(), contentsWidth(), d->currentItem->height());
+item = findItem(dir, d->currentItem->rect().center(), r);
+// search the row below from the right
+while (!item && r.y() < contentsHeight()) {
+r.moveBy(0, d->currentItem->height());
+item = findItem(dir, QPoint(0, r.center().y()), r);
+}
+if (item) {
+Q3IconViewItem *old = d->currentItem;
+setCurrentItem(item);
+ensureItemVisible(item);
+handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton);
+}
+} break;
+case Qt::Key_Left: {
+d->currInputString.clear();
+Q3IconViewItem *item;
+selectCurrent = false;
+Direction dir = DirLeft;
+QRect r(0, d->currentItem->y(), contentsWidth(), d->currentItem->height());
+item = findItem(dir, d->currentItem->rect().center(), r);
+// search the row above from the left
+while (!item && r.y() >= 0) {
+r.moveBy(0, - d->currentItem->height());
+item = findItem(dir, QPoint(contentsWidth(), r.center().y()), r);
+}
+if (item) {
+Q3IconViewItem *old = d->currentItem;
+setCurrentItem(item);
+ensureItemVisible(item);
+handleItemChange(old, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton);
+}
+} break;
+case Qt::Key_Space: {
+d->currInputString.clear();
+if (d->selectionMode == Single)
+break;
+d->currentItem->setSelected(!d->currentItem->isSelected(), true);
+} break;
+case Qt::Key_Enter: case Qt::Key_Return:
+d->currInputString.clear();
+emit returnPressed(d->currentItem);
+break;
+case Qt::Key_Down: {
+d->currInputString.clear();
+Q3IconViewItem *item;
+selectCurrent = false;
+Direction dir = DirDown;
+QRect r(d->currentItem->x(), 0, d->currentItem->width(), contentsHeight());
+item = findItem(dir, d->currentItem->rect().center(), r);
+// finding the closest item below and to the right
+while (!item && r.x() < contentsWidth()) {
+r.moveBy(r.width() , 0);
+item = findItem(dir, QPoint(r.center().x(), 0), r);
+}
+Q3IconViewItem *i = d->currentItem;
+setCurrentItem(item);
+item = i;
+handleItemChange(item, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton);
+} break;
+case Qt::Key_Up: {
+d->currInputString.clear();
+Q3IconViewItem *item;
+selectCurrent = false;
+Direction dir = DirUp;
+QRect r(d->currentItem->x(), 0, d->currentItem->width(), contentsHeight());
+item = findItem(dir, d->currentItem->rect().center(), r);
+// finding the closest item above and to the left
+while (!item && r.x() >= 0) {
+r.moveBy(- r.width(), 0);
+item = findItem(dir, QPoint(r.center().x(), contentsHeight()), r);
+}
+Q3IconViewItem *i = d->currentItem;
+setCurrentItem(item);
+item = i;
+handleItemChange(item, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton);
+} break;
+case Qt::Key_Next: {
+d->currInputString.clear();
+selectCurrent = false;
+QRect r;
+if (d->arrangement == LeftToRight)
+r = QRect(0, d->currentItem->y() + visibleHeight(), contentsWidth(), visibleHeight());
+else
+r = QRect(d->currentItem->x() + visibleWidth(), 0, visibleWidth(), contentsHeight());
+Q3IconViewItem *item = d->currentItem;
+Q3IconViewItem *ni = findFirstVisibleItem(r );
+if (!ni) {
+if (d->arrangement == LeftToRight)
+r = QRect(0, d->currentItem->y() + d->currentItem->height(), contentsWidth(), contentsHeight());
+else
+r = QRect(d->currentItem->x() + d->currentItem->width(), 0, contentsWidth(), contentsHeight());
+ni = findLastVisibleItem(r );
+}
+if (ni) {
+setCurrentItem(ni);
+handleItemChange(item, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton);
+}
+} break;
+case Qt::Key_Prior: {
+d->currInputString.clear();
+selectCurrent = false;
+QRect r;
+if (d->arrangement == LeftToRight)
+r = QRect(0, d->currentItem->y() - visibleHeight(), contentsWidth(), visibleHeight());
+else
+r = QRect(d->currentItem->x() - visibleWidth(), 0, visibleWidth(), contentsHeight());
+Q3IconViewItem *item = d->currentItem;
+Q3IconViewItem *ni = findFirstVisibleItem(r );
+if (!ni) {
+if (d->arrangement == LeftToRight)
+r = QRect(0, 0, contentsWidth(), d->currentItem->y());
+else
+r = QRect(0, 0, d->currentItem->x(), contentsHeight());
+ni = findFirstVisibleItem(r );
+}
+if (ni) {
+setCurrentItem(ni);
+handleItemChange(item, e->state() & Qt::ShiftButton, e->state() & Qt::ControlButton);
+}
+} break;
+default:
+if (!e->text().isEmpty() && e->text()[0].isPrint()) {
+selectCurrent = false;
+Q3IconViewItem *i = d->currentItem;
+if (!i)
+i = d->firstItem;
+if (!d->inputTimer->isActive()) {
+d->currInputString = e->text();
+i = i->next;
+if (!i)
+i = d->firstItem;
+i = findItemByName(i);
+} else {
+d->inputTimer->stop();
+d->currInputString += e->text();
+i = findItemByName(i);
+if (!i) {
+d->currInputString = e->text();
+if (d->currentItem && d->currentItem->next)
+i = d->currentItem->next;
+else
+i = d->firstItem;
+i = findItemByName(i);
+}
+}
+if (i) {
+setCurrentItem(i);
+if (d->selectionMode == Extended) {
+bool changed = false;
+bool block = signalsBlocked();
+blockSignals(true);
+selectAll(false);
+blockSignals(block);
+if (!i->selected && i->isSelectable()) {
+changed = true;
+i->selected = true;
+repaintItem(i);
+}
+if (changed)
+emit selectionChanged();
+}
+}
+d->inputTimer->start(400, true);
+} else {
+selectCurrent = false;
+d->currInputString.clear();
+if (e->state() & Qt::ControlButton) {
+switch (e->key()) {
+case Qt::Key_A:
+selectAll(true);
+break;
+}
+}
+e->ignore();
+return;
+}
+}
+if (!(e->state() & Qt::ShiftButton) || !d->selectAnchor)
+d->selectAnchor = d->currentItem;
+if (d->currentItem && !d->currentItem->isSelected() &&
+d->selectionMode == Single && selectCurrent) {
+d->currentItem->setSelected(true);
+}
+ensureItemVisible(d->currentItem);
+}
+/*
+Finds the closest item in the Direction \a dir relative from the point \a relativeTo
+which intersects with the searchRect.
+The function chooses the closest item with its center in the \a searchRect.
+*/
+Q3IconViewItem* Q3IconView::findItem(Direction dir,
+const QPoint &relativeTo,
+const QRect &searchRect) const
+{
+Q3IconViewItem *centerMatch = 0;
+int centerMatchML = 0;
+// gets list of containers with potential items
+QList<Q3IconViewPrivate::ItemContainer * >* cList =
+d->findContainers(dir, relativeTo, searchRect);
+for (int i = 0; i < cList->size() && !centerMatch; ++i) {
+QList<Q3IconViewItem *> &list = (cList->at(i))->items;
+for (int j = 0; j < list.size(); ++j) {
+Q3IconViewItem *item = list.at(j);
+if (neighbourItem(dir, relativeTo, item) &&
+searchRect.contains(item->rect().center()) && item != currentItem()) {
+int ml = (relativeTo - item->rect().center()).manhattanLength();
+if (centerMatch) {
+if (ml < centerMatchML) {
+centerMatch = item;
+centerMatchML = ml;
+}
+} else {
+centerMatch = item;
+centerMatchML = ml;
+}
+}
+}
+}
+return centerMatch;
+}
+/*
+Returns true if the items orientation compared to
+the point \a relativeTo is correct.
+*/
+bool Q3IconView::neighbourItem(Direction dir,
+const QPoint &relativeTo,
+const Q3IconViewItem *item) const
+{
+switch (dir) {
+case DirUp:
+if (item->rect().center().y() < relativeTo.y())
+return true;
+break;
+case DirDown:
+if (item->rect().center().y() > relativeTo.y())
+return true;
+break;
+case DirLeft:
+if (item->rect().center().x() < relativeTo.x())
+return true;
+break;
+case DirRight:
+if (item->rect().center().x() > relativeTo.x())
+return true;
+break;
+default:
+// nothing
+break;
+}
+return false;
+}
+/*!
+\reimp
+*/
+void Q3IconView::focusInEvent(QFocusEvent *e)
+{
+d->mousePressed = false;
+d->inMenuMode = false;
+if (d->currentItem) {
+repaintItem(d->currentItem);
+} else if (d->firstItem && e->reason() != Qt::MouseFocusReason) {
+d->currentItem = d->firstItem;
+emit currentChanged(d->currentItem);
+repaintItem(d->currentItem);
+}
+if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this))
+repaintSelectedItems();
+}
+/*!
+\reimp
+*/
+void Q3IconView::focusOutEvent(QFocusEvent *e)
+{
+if (style()->styleHint(QStyle::SH_ItemView_ChangeHighlightOnFocus, 0, this)) {
+d->inMenuMode =
+e->reason() == Qt::PopupFocusReason ||
+(qApp->focusWidget() && qApp->focusWidget()->inherits("QMenuBar"));
+if (!d->inMenuMode)
+repaintSelectedItems();
+}
+if (d->currentItem)
+repaintItem(d->currentItem);
+}
+/*!
+Draws the rubber band using the painter \a p.
+*/
+void Q3IconView::drawRubber(QPainter *p)
+{
+if (!p || !d->rubber)
+return;
+QStyleOptionRubberBand opt;
+opt.rect = d->rubber->normalized();
+opt.shape = QRubberBand::Rectangle;
+opt.palette = palette();
+opt.state = QStyle::State_None;
+style()->drawControl(QStyle::CE_RubberBand, &opt, p, this);
+}
+/*!
+Returns the Q3DragObject that should be used for drag-and-drop.
+This function is called by the icon view when starting a drag to
+get the dragobject that should be used for the drag. Subclasses
+may reimplement this.
+\sa Q3IconDrag
+*/
+#ifndef QT_NO_DRAGANDDROP
+Q3DragObject *Q3IconView::dragObject()
+{
+if (!d->currentItem)
+return 0;
+QPoint orig = d->dragStartPos;
+Q3IconDrag *drag = new Q3IconDrag(viewport());
+drag->setPixmap((d->currentItem->pixmap() ?
+*d->currentItem->pixmap() : QPixmap()), // ### QPicture
+QPoint(d->currentItem->pixmapRect().width() / 2,
+d->currentItem->pixmapRect().height() / 2));
+if (d->selectionMode == NoSelection) {
+Q3IconViewItem *item = d->currentItem;
+drag->append(Q3IconDragItem(),
+QRect(item->pixmapRect(false).x() - orig.x(),
+item->pixmapRect(false).y() - orig.y(),
+item->pixmapRect().width(), item->pixmapRect().height()),
+QRect(item->textRect(false).x() - orig.x(),
+item->textRect(false).y() - orig.y(),
+item->textRect().width(), item->textRect().height()));
+} else {
+for (Q3IconViewItem *item = d->firstItem; item; item = item->next) {
+if (item->isSelected()) {
+drag->append(Q3IconDragItem(),
+QRect(item->pixmapRect(false).x() - orig.x(),
+item->pixmapRect(false).y() - orig.y(),
+item->pixmapRect().width(), item->pixmapRect().height()),
+QRect(item->textRect(false).x() - orig.x(),
+item->textRect(false).y() - orig.y(),
+item->textRect().width(), item->textRect().height()));
+}
+}
+}
+return drag;
+}
+/*!
+Starts a drag.
+*/
+void Q3IconView::startDrag()
+{
+if (!d->startDragItem)
+return;
+QPoint orig = d->dragStartPos;
+d->dragStart = QPoint(orig.x() - d->startDragItem->x(),
+orig.y() - d->startDragItem->y());
+d->startDragItem = 0;
+d->mousePressed = false;
+d->pressedItem = 0;
+d->pressedSelected = 0;
+Q3DragObject *drag = dragObject();
+if (!drag)
+return;
+if (drag->drag())
+if (drag->target() != viewport())
+emit moved();
+}
+#endif
+/*!
+Inserts the Q3IconViewItem \a item in the icon view's grid. \e{You
+should never need to call this function.} Instead, insert
+Q3IconViewItems by creating them with a pointer to the Q3IconView
+that they are to be inserted into.
+*/
+void Q3IconView::insertInGrid(Q3IconViewItem *item)
+{
+if (!item)
+return;
+if (d->reorderItemsWhenInsert) {
+// #### make this efficient - but it's not too dramatic
+int y = d->spacing;
+item->dirty = false;
+if (item == d->firstItem) {
+bool dummy;
+makeRowLayout(item, y, dummy);
+return;
+}
+Q3IconViewItem *begin = rowBegin(item);
+y = begin->y();
+while (begin) {
+bool dummy;
+begin = makeRowLayout(begin, y, dummy);
+if (!begin || !begin->next)
+break;
+begin = begin->next;
+}
+item->dirty = false;
+} else {
+QRegion r(QRect(0, 0, qMax(contentsWidth(), visibleWidth()),
+qMax(contentsHeight(), visibleHeight())));
+int y = -1;
+for (Q3IconViewItem *i = d->firstItem; i; i = i->next) {
+r = r.subtracted(i->rect());
+y = qMax(y, i->y() + i->height());
+}
+QVector<QRect> rects = r.rects();
+bool foundPlace = false;
+for (int j = 0; j < rects.size(); ++j) {
+const QRect rect = rects.at(j);
+if (rect.width() >= item->width() &&
+rect.height() >= item->height()) {
+int sx = 0, sy = 0;
+if (rect.width() >= item->width() + d->spacing)
+sx = d->spacing;
+if (rect.height() >= item->height() + d->spacing)
+sy = d->spacing;
+item->move(rect.x() + sx, rect.y() + sy);
+foundPlace = true;
+break;
+}
+}
+if (!foundPlace)
+item->move(d->spacing, y + d->spacing);
+resizeContents(qMax(contentsWidth(), item->x() + item->width()),
+qMax(contentsHeight(), item->y() + item->height()));
+item->dirty = false;
+}
+}
+/*!
+Emits a signal to indicate selection changes. \a i is the
+Q3IconViewItem that was selected or de-selected.
+\e{You should never need to call this function.}
+*/
+void Q3IconView::emitSelectionChanged(Q3IconViewItem *i)
+{
+emit selectionChanged();
+if (d->selectionMode == Single)
+emit selectionChanged(i ? i : d->currentItem);
+}
+/*!
+\internal
+*/
+void Q3IconView::emitRenamed(Q3IconViewItem *item)
+{
+if (!item)
+return;
+emit itemRenamed(item, item->text());
+emit itemRenamed(item);
+}
+/*!
+If a drag enters the icon view the shapes of the objects which the
+drag contains are drawn, usnig \a pos as origin.
+*/
+void Q3IconView::drawDragShapes(const QPoint &pos)
+{
+#ifndef QT_NO_DRAGANDDROP
+if (pos == QPoint(-1, -1))
+return;
+if (!d->drawDragShapes) {
+d->drawDragShapes = true;
+return;
+}
+d->dragPos = pos;
+viewport()->update();
+#endif
+}
+/*!
+When a drag enters the icon view, this function is called to
+initialize it. Initializing in this context means getting
+information about the drag, for example so that the icon view
+knows enough about the drag to be able to draw drag shapes for the
+drag data (e.g. shapes of icons which are dragged), etc.
+*/
+#ifndef QT_NO_DRAGANDDROP
+void Q3IconView::initDragEnter(QDropEvent *e)
+{
+if (Q3IconDrag::canDecode(e)) {
+Q3IconDragPrivate::decode(e, d->iconDragData);
+d->isIconDrag = true;
+} else if (Q3UriDrag::canDecode(e)) {
+Q3StrList lst;
+Q3UriDrag::decode(e, lst);
+d->numDragItems = lst.count();
+} else {
+d->numDragItems = 0;
+}
+}
+#endif
+/*!
+This function is called to draw the rectangle \a r of the
+background using the painter \a p.
+The default implementation fills \a r with the viewport's
+backgroundBrush(). Subclasses can reimplement this to draw custom
+backgrounds.
+\sa drawContents()
+*/
+void Q3IconView::drawBackground(QPainter *p, const QRect &r)
+{
+p->fillRect(r, viewport()->backgroundBrush());
+}
+/*!
+\reimp
+*/
+bool Q3IconView::eventFilter(QObject * o, QEvent * e)
+{
+if (o == viewport()) {
+switch(e->type()) {
+case QEvent::FocusIn:
+focusInEvent((QFocusEvent*)e);
+return true;
+case QEvent::FocusOut:
+focusOutEvent((QFocusEvent*)e);
+return true;
+case QEvent::Enter:
+enterEvent(e);
+return true;
+case QEvent::Paint:
+if (o == viewport()) {
+viewportPaintEvent((QPaintEvent*)e);
+QPainter p(viewport());
+if (d->dragging) {
+if (!d->rubber && d->drawDragShapes) {
+p.setPen(QPen(Qt::color0));
+QStyleOptionFocusRect opt;
+opt.palette = palette();
+opt.state = QStyle::State_KeyboardFocusChange;
+opt.backgroundColor = palette().base().color();
+if (d->isIconDrag) {
+d->dragPos = contentsToViewport(d->dragPos);
+QLinkedList<Q3IconDragDataItem>::Iterator it = d->iconDragData.begin();
+for (; it != d->iconDragData.end(); ++it) {
+QRect ir = (*it).item.pixmapRect();
+QRect tr = (*it).item.textRect();
+tr.moveBy(d->dragPos.x(), d->dragPos.y());
+ir.moveBy(d->dragPos.x(), d->dragPos.y());
+if (!ir.intersects(QRect(0, 0, visibleWidth(), visibleHeight())))
+continue;
+opt.rect = ir;
+style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, &p, this);
+opt.rect = tr;
+p.drawRect(tr);
+style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, &p, this);
+}
+} else if (d->numDragItems > 0) {
+for (int i = 0; i < d->numDragItems; ++i) {
+opt.rect.setRect(d->dragPos.x() + i * 40, d->dragPos.y(), 35, 35);
+style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, &p, this);
+}
+}
+p.end();
+}
+} else {
+p.translate(-contentsX(), -contentsY());
+drawRubber(&p);
+}
+}
+return true;
+#ifndef QT_NO_TOOLTIP
+case QHelpEvent::ToolTip:
+{
+if (wordWrapIconText() || !showToolTips())
+return false;
+QHelpEvent *he = static_cast<QHelpEvent *>(e);
+Q3IconViewItem *item = findItem(viewportToContents(he->pos()));
+if (!item || item->tmpText == item->itemText) {
+QToolTip::showText(he->globalPos(), QString(), viewport());
+return true;
+}
+QToolTip::showText(he->globalPos(), item->itemText, viewport());
+return true;
+}
+#endif
+default:
+// nothing
+break;
+}
+}
+return Q3ScrollView::eventFilter(o, e);
+}
+/*!
+\reimp
+*/
+QSize Q3IconView::minimumSizeHint() const
+{
+return Q3ScrollView::minimumSizeHint();
+}
+/*!
+\internal
+Finds the next item after the start item beginning
+with \a text.
+*/
+Q3IconViewItem* Q3IconView::findItemByName(Q3IconViewItem *start)
+{
+if (!start)
+return 0;
+QString match = d->currInputString.toLower();
+if (match.length() < 1)
+return start;
+QString curText;
+Q3IconViewItem *i = start;
+do {
+curText = i->text().toLower();
+if (curText.startsWith(match))
+return i;
+i = i->next;
+if (!i)
+i = d->firstItem;
+} while (i != start);
+return 0;
+}
+/*!
+Lays out a row of icons (if Arrangement == \l TopToBottom this is
+a column). Starts laying out with the item \a begin. \a y is the
+starting coordinate. Returns the last item of the row (column) and
+sets the new starting coordinate to \a y. The \a changed parameter
+is used internally.
+\warning This function may be made private in a future version of
+Qt. We do not recommend calling it.
+*/
+Q3IconViewItem *Q3IconView::makeRowLayout(Q3IconViewItem *begin, int &y, bool &changed)
+{
+Q3IconViewItem *end = 0;
+bool reverse = QApplication::reverseLayout();
+changed = false;
+if (d->arrangement == LeftToRight) {
+if (d->rastX == -1) {
+// first calculate the row height
+int h = 0;
+int x = 0;
+int ih = 0;
+Q3IconViewItem *item = begin;
+for (;;) {
+x += d->spacing + item->width();
+if (x > visibleWidth() && item != begin) {
+item = item->prev;
+break;
+}
+h = qMax(h, item->height());
+ih = qMax(ih, item->pixmapRect().height());
+Q3IconViewItem *old = item;
+item = item->next;
+if (!item) {
+item = old;
+break;
+}
+}
+end = item;
+if (d->rastY != -1)
+h = qMax(h, d->rastY);
+// now move the items
+item = begin;
+for (;;) {
+item->dirty = false;
+int x;
+if (item == begin) {
+if (reverse)
+x = visibleWidth() - d->spacing - item->width();
+else
+x = d->spacing;
+} else {
+if (reverse)
+x = item->prev->x() - item->width() - d->spacing;
+else
+x = item->prev->x() + item->prev->width() + d->spacing;
+}
+changed = item->move(x, y + ih - item->pixmapRect().height()) || changed;
+if (y + h < item->y() + item->height())
+h = qMax(h, ih + item->textRect().height());
+if (item == end)
+break;
+item = item->next;
+}
+y += h + d->spacing;
+} else {
+// first calculate the row height
+int h = begin->height();
+int x = d->spacing;
+int ih = begin->pixmapRect().height();
+Q3IconViewItem *item = begin;
+int i = 0;
+int sp = 0;
+for (;;) {
+int r = calcGridNum(item->width(), d->rastX);
+if (item == begin) {
+i += r;
+sp += r;
+x = d->spacing + d->rastX * r;
+} else {
+sp += r;
+i += r;
+x = i * d->rastX + sp * d->spacing;
+}
+if (x > visibleWidth() && item != begin) {
+item = item->prev;
+break;
+}
+h = qMax(h, item->height());
+ih = qMax(ih, item->pixmapRect().height());
+Q3IconViewItem *old = item;
+item = item->next;
+if (!item) {
+item = old;
+break;
+}
+}
+end = item;
+if (d->rastY != -1)
+h = qMax(h, d->rastY);
+// now move the items
+item = begin;
+i = 0;
+sp = 0;
+for (;;) {
+item->dirty = false;
+int r = calcGridNum(item->width(), d->rastX);
+if (item == begin) {
+if (d->itemTextPos == Bottom)
+changed = item->move(d->spacing + (r * d->rastX - item->width()) / 2,
+y + ih - item->pixmapRect().height()) || changed;
+else
+changed = item->move(d->spacing, y + ih - item->pixmapRect().height()) || changed;
+i += r;
+sp += r;
+} else {
+sp += r;
+int x = i * d->rastX + sp * d->spacing;
+if (d->itemTextPos == Bottom)
+changed = item->move(x + (r * d->rastX - item->width()) / 2,
+y + ih - item->pixmapRect().height()) || changed;
+else
+changed = item->move(x, y + ih - item->pixmapRect().height()) || changed;
+i += r;
+}
+if (y + h < item->y() + item->height())
+h = qMax(h, ih + item->textRect().height());
+if (item == end)
+break;
+item = item->next;
+}
+y += h + d->spacing;
+}
+} else { // -------------------------------- SOUTH ------------------------------
+int x = y;
+{
+int w = 0;
+int y = 0;
+Q3IconViewItem *item = begin;
+for (;;) {
+y += d->spacing + item->height();
+if (y > visibleHeight() && item != begin) {
+item = item->prev;
+break;
+}
+w = qMax(w, item->width());
+Q3IconViewItem *old = item;
+item = item->next;
+if (!item) {
+item = old;
+break;
+}
+}
+end = item;
+if (d->rastX != -1)
+w = qMax(w, d->rastX);
+// now move the items
+item = begin;
+for (;;) {
+item->dirty = false;
+if (d->itemTextPos == Bottom) {
+if (item == begin)
+changed = item->move(x + (w - item->width()) / 2, d->spacing)  || changed;
+else
+changed = item->move(x + (w - item->width()) / 2,
+item->prev->y() + item->prev->height() + d->spacing) || changed;
+} else {
+if (item == begin)
+changed = item->move(x, d->spacing) || changed;
+else
+changed = item->move(x, item->prev->y() + item->prev->height() + d->spacing) || changed;
+}
+if (item == end)
+break;
+item = item->next;
+}
+x += w + d->spacing;
+}
+y = x;
+}
+return end;
+}
+/*!
+\internal
+Calculates how many cells an item of width \a w needs in a grid with of
+\a x and returns the result.
+*/
+int Q3IconView::calcGridNum(int w, int x) const
+{
+float r = (float)w / (float)x;
+if ((w / x) * x != w)
+r += 1.0;
+return (int)r;
+}
+/*!
+\internal
+Returns the first item of the row which contains \a item.
+*/
+Q3IconViewItem *Q3IconView::rowBegin(Q3IconViewItem *) const
+{
+// #### todo
+return d->firstItem;
+}
+/*!
+Sorts and rearranges all the items in the icon view. If \a
+ascending is true, the items are sorted in increasing order,
+otherwise they are sorted in decreasing order.
+Q3IconViewItem::compare() is used to compare pairs of items. The
+sorting is based on the items' keys; these default to the items'
+text unless specifically set to something else.
+Note that this function sets the sort order to \a ascending.
+\sa Q3IconViewItem::key(), Q3IconViewItem::setKey(),
+Q3IconViewItem::compare(), Q3IconView::setSorting(),
+Q3IconView::sortDirection()
+*/
+void Q3IconView::sort(bool ascending)
+{
+if (count() == 0)
+return;
+d->sortDirection = ascending;
+Q3IconViewPrivate::SortableItem *items = new Q3IconViewPrivate::SortableItem[count()];
+Q3IconViewItem *item = d->firstItem;
+int i = 0;
+for (; item; item = item->next)
+items[i++].item = item;
+qsort(items, count(), sizeof(Q3IconViewPrivate::SortableItem), cmpIconViewItems);
+Q3IconViewItem *prev = 0;
+item = 0;
+if (ascending) {
+for (i = 0; i < (int)count(); ++i) {
+item = items[i].item;
+if (item) {
+item->prev = prev;
+if (item->prev)
+item->prev->next = item;
+item->next = 0;
+}
+if (i == 0)
+d->firstItem = item;
+if (i == (int)count() - 1)
+d->lastItem = item;
+prev = item;
+}
+} else {
+for (i = (int)count() - 1; i >= 0 ; --i) {
+item = items[i].item;
+if (item) {
+item->prev = prev;
+if (item->prev)
+item->prev->next = item;
+item->next = 0;
+}
+if (i == (int)count() - 1)
+d->firstItem = item;
+if (i == 0)
+d->lastItem = item;
+prev = item;
+}
+}
+delete [] items;
+arrangeItemsInGrid(true);
+}
+/*!
+\reimp
+*/
+QSize Q3IconView::sizeHint() const
+{
+ensurePolished();
+if (!d->firstItem)
+return Q3ScrollView::sizeHint();
+if (d->dirty && d->firstSizeHint) {
+((Q3IconView*)this)->resizeContents(qMax(400, contentsWidth()),
+qMax(400, contentsHeight()));
+if (autoArrange())
+((Q3IconView*)this)->arrangeItemsInGrid(false);
+d->firstSizeHint = false;
+}
+d->dirty = true;
+const QScrollBar *sb = verticalScrollBar();
+QStyleOptionSlider opt;
+opt.init(sb);
+opt.orientation = sb->orientation();
+int extra = style()->pixelMetric(QStyle::PM_ScrollBarExtent, &opt, sb) + 2 * frameWidth();
+QSize s(qMin(400, contentsWidth() + extra),
+qMin(400, contentsHeight() + extra));
+return s;
+}
+/*!
+\internal
+*/
+void Q3IconView::updateContents()
+{
+viewport()->update();
+}
+/*!
+\reimp
+*/
+void Q3IconView::enterEvent(QEvent *e)
+{
+Q3ScrollView::enterEvent(e);
+emit onViewport();
+}
+/*!
+\internal
+This function is always called when the geometry of an item changes.
+This function moves the item into the correct area in the internal
+data structure.
+*/
+void Q3IconView::updateItemContainer(Q3IconViewItem *item)
+{
+if (!item || d->containerUpdateLocked || (!isVisible() && autoArrange()))
+return;
+if (item->d->container1 && d->firstContainer) {
+//Special-case to check if we can use removeLast otherwise use removeAll (slower)
+if (item->d->container1->items.last() == item)
+item->d->container1->items.removeLast();
+else
+item->d->container1->items.removeAll(item);
+}
+item->d->container1 = 0;
+if (item->d->container2 && d->firstContainer) {
+//Special-case to check if we can use removeLast otherwise use removeAll (slower)
+if (item->d->container2->items.last() == item)
+item->d->container2->items.removeLast();
+else
+item->d->container2->items.removeAll(item);
+}
+item->d->container2 = 0;
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer;
+if (!c) {
+appendItemContainer();
+c = d->firstContainer;
+}
+const QRect irect = item->rect();
+bool contains = false;
+for (;;) {
+if (c->rect.intersects(irect)) {
+contains = c->rect.contains(irect);
+break;
+}
+c = c->n;
+if (!c) {
+appendItemContainer();
+c = d->lastContainer;
+}
+}
+if (!c) {
+qWarning("Q3IconViewItem::updateItemContainer(): No fitting container found!");
+return;
+}
+c->items.append(item);
+item->d->container1 = c;
+if (!contains) {
+c = c->n;
+if (!c) {
+appendItemContainer();
+c = d->lastContainer;
+}
+c->items.append(item);
+item->d->container2 = c;
+}
+if (contentsWidth() < irect.right() || contentsHeight() < irect.bottom())
+resizeContents(qMax(contentsWidth(), irect.right()), qMax(contentsHeight(), irect.bottom()));
+}
+/*!
+\internal
+Appends a new rect area to the internal data structure of the items.
+*/
+void Q3IconView::appendItemContainer()
+{
+QSize s;
+// #### We have to find out which value is best here
+if (d->arrangement == LeftToRight)
+s = QSize(INT_MAX - 1, RECT_EXTENSION);
+else
+s = QSize(RECT_EXTENSION, INT_MAX - 1);
+if (!d->firstContainer) {
+d->firstContainer = new Q3IconViewPrivate::ItemContainer(0, 0, QRect(QPoint(0, 0), s));
+d->lastContainer = d->firstContainer;
+} else {
+if (d->arrangement == LeftToRight)
+d->lastContainer = new Q3IconViewPrivate::ItemContainer(
+d->lastContainer, 0, QRect(d->lastContainer->rect.bottomLeft(), s));
+else
+d->lastContainer = new Q3IconViewPrivate::ItemContainer(
+d->lastContainer, 0, QRect(d->lastContainer->rect.topRight(), s));
+}
+}
+/*!  \internal
+Rebuilds the whole internal data structure. This is done when it's
+likely that most/all items change their geometry (e.g. in
+arrangeItemsInGrid()), because calling this is then more efficient
+than calling updateItemContainer() for each item.
+*/
+void Q3IconView::rebuildContainers()
+{
+Q3IconViewPrivate::ItemContainer *c = d->firstContainer, *tmpc;
+while (c) {
+tmpc = c->n;
+delete c;
+c = tmpc;
+}
+d->firstContainer = d->lastContainer = 0;
+Q3IconViewItem *item = d->firstItem;
+appendItemContainer();
+c = d->lastContainer;
+while (item) {
+if (c->rect.contains(item->rect())) {
+item->d->container1 = c;
+item->d->container2 = 0;
+c->items.append(item);
+item = item->next;
+} else if (c->rect.intersects(item->rect())) {
+item->d->container1 = c;
+c->items.append(item);
+c = c->n;
+if (!c) {
+appendItemContainer();
+c = d->lastContainer;
+}
+c->items.append(item);
+item->d->container2 = c;
+item = item->next;
+c = c->p;
+} else {
+if (d->arrangement == LeftToRight) {
+if (item->y() < c->rect.y() && c->p) {
+c = c->p;
+continue;
+}
+} else {
+if (item->x() < c->rect.x() && c->p) {
+c = c->p;
+continue;
+}
+}
+c = c->n;
+if (!c) {
+appendItemContainer();
+c = d->lastContainer;
+}
+}
+}
+}
+/*!
+\internal
+*/
+void Q3IconView::movedContents(int, int)
+{
+if (d->drawDragShapes) {
+drawDragShapes(d->oldDragPos);
+d->oldDragPos = QPoint(-1, -1);
+}
+}
+void Q3IconView::handleItemChange(Q3IconViewItem *old, bool shift,
+bool control, bool homeend)
+{
+if (d->selectionMode == Single) {
+bool block = signalsBlocked();
+blockSignals(true);
+if (old)
+old->setSelected(false);
+blockSignals(block);
+d->currentItem->setSelected(true, true);
+} else if (d->selectionMode == Extended) {
+if (shift) {
+if (!d->selectAnchor) {
+if (old && !old->selected && old->isSelectable()) {
+old->selected = true;
+repaintItem(old);
+}
+d->currentItem->setSelected(true, true);
+} else {
+Q3IconViewItem *from = d->selectAnchor, *to = d->currentItem;
+if (!from || !to)
+return;
+// checking if it's downwards and if we span rows
+bool downwards = false;
+bool spanning = false;
+if (d->arrangement == LeftToRight) {
+if (from->rect().center().y() < to->rect().center().y())
+downwards = true;
+} else {
+if (from->rect().center().x() < to->rect().center().x())
+downwards = true;
+}
+QRect fr = from->rect();
+QRect tr = to->rect();
+if (d->arrangement == LeftToRight) {
+fr.moveTopLeft(QPoint(tr.x(), fr.y()));
+if (!tr.intersects(fr))
+spanning = true;
+} else {
+fr.moveTopLeft(QPoint(fr.x(), tr.y()));
+if (!tr.intersects(fr))
+spanning = true;
+}
+// finding the rectangles
+QRect topRect, bottomRect, midRect;
+if (!spanning) {
+midRect = from->rect().united(to->rect());
+} else {
+if (downwards) {
+topRect = from->rect();
+bottomRect = to->rect();
+} else {
+topRect = to->rect();
+bottomRect = from->rect();
+}
+if (d->arrangement == LeftToRight) {
+topRect.setRight(contentsWidth());
+bottomRect.setLeft(0);
+midRect.setRect(0, topRect.bottom(),
+contentsWidth(),
+bottomRect.top() - topRect.bottom());
+} else {
+topRect.setBottom(contentsHeight());
+bottomRect.setTop(0);
+midRect.setRect(topRect.right(),
+0,
+bottomRect.left() - topRect.right(),
+contentsHeight());
+}
+}
+// finding contained items and selecting them
+Q3IconViewItem *item = 0;
+bool changed = false;
+bool midValid = midRect.isValid();
+bool topValid = topRect.isValid();
+bool bottomValid = bottomRect.isValid();
+QRect selectedRect, unselectedRect;
+for (item = d->firstItem; item; item = item->next) {
+bool contained = false;
+QPoint itemCenter = item->rect().center();
+if (midValid && midRect.contains(itemCenter))
+contained = true;
+if (!contained && topValid && topRect.contains(itemCenter))
+contained = true;
+if (!contained && bottomValid && bottomRect.contains(itemCenter))
+contained = true;
+if (contained) {
+if (!item->selected && item->isSelectable()) {
+changed = true;
+item->selected = true;
+selectedRect = selectedRect.united(item->rect());
+}
+} else if (item->selected && !control) {
+item->selected = false;
+unselectedRect = unselectedRect.united(item->rect());
+changed = true;
+}
+}
+QRect viewRect(contentsX(), contentsY(),
+visibleWidth(), visibleHeight());
+if (viewRect.intersects(selectedRect)) {
+if (homeend)
+Q3ScrollView::updateContents(viewRect.intersected(selectedRect));
+else
+repaintContents(viewRect.intersected(selectedRect));
+}
+if (viewRect.intersects(unselectedRect)) {
+if (homeend)
+Q3ScrollView::updateContents(viewRect.intersected(unselectedRect));
+else
+repaintContents(viewRect.intersected(unselectedRect));
+}
+if (changed)
+emit selectionChanged();
+}
+} else if (!control) {
+blockSignals(true);
+selectAll(false);
+blockSignals(false);
+d->currentItem->setSelected(true, true);
+}
+} else {
+if (shift)
+d->currentItem->setSelected(!d->currentItem->isSelected(), true);
+}
+}
+QBitmap Q3IconView::mask(QPixmap *pix) const
+{
+QBitmap m;
+if (d->maskCache.find(QString::number(pix->serialNumber()), m))
+return m;
+if (pix->hasAlphaChannel())
+m = pix->mask();
+else
+m = pix->createHeuristicMask();
+d->maskCache.insert(QString::number(pix->serialNumber()), m);
+return m;
+}
+/*!
+Returns true if an iconview item is being renamed; otherwise
+returns false.
+*/
+bool Q3IconView::isRenaming() const
+{
+#ifndef QT_NO_TEXTEDIT
+return d->renamingItem && d->renamingItem->renameBox;
+#else
+return false;
+#endif
+}
+/*!
+\enum Q3IconView::StringComparisonMode
+This enum type is used to set the string comparison mode when
+searching for an item. We'll refer to the string being searched
+as the 'target' string.
+\value CaseSensitive The strings must match case sensitively.
+\value ExactMatch The target and search strings must match exactly.
+\value BeginsWith The target string begins with the search string.
+\value EndsWith The target string ends with the search string.
+\value Contains The target string contains the search string.
+If you OR these flags together (excluding \c CaseSensitive), the
+search criteria be applied in the following order: \c ExactMatch,
+\c BeginsWith, \c EndsWith, \c Contains.
+Matching is case-insensitive unless \c CaseSensitive is set. \c
+CaseSensitive can be OR-ed with any combination of the other
+flags.
+\sa ComparisonFlags
+*/
+/*!
+\typedef Q3IconView::ComparisonFlags
+This typedef is used in Q3IconView's API for values that are OR'd
+combinations of \l StringComparisonMode values.
+\sa StringComparisonMode
+*/
+QT_END_NAMESPACE
+#endif // QT_NO_ICONVIEW

changeset 0	1918ee327afb
child 4	3b1da2848fc7