1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qlistwidget.h"

    43 

    44 #ifndef QT_NO_LISTWIDGET

    45 #include <qitemdelegate.h>

    46 #include <private/qlistview_p.h>

    47 #include <private/qwidgetitemdata_p.h>

    48 #include <private/qlistwidget_p.h>

    49 

    50 QT_BEGIN_NAMESPACE

    51 

    52 // workaround for VC++ 6.0 linker bug (?)

    53 typedef bool(*LessThan)(const QPair<QListWidgetItem*,int>&,const QPair<QListWidgetItem*,int>&);

    54 

    55 class QListWidgetMimeData : public QMimeData

    56 {

    57     Q_OBJECT

    58 public:

    59     QList<QListWidgetItem*> items;

    60 };

    61 

    62 QT_BEGIN_INCLUDE_NAMESPACE

    63 #include "qlistwidget.moc"

    64 QT_END_INCLUDE_NAMESPACE

    65 

    66 QListModel::QListModel(QListWidget *parent)

    67     : QAbstractListModel(parent)

    68 {

    69 }

    70 

    71 QListModel::~QListModel()

    72 {

    73     clear();

    74 }

    75 

    76 void QListModel::clear()

    77 {

    78     for (int i = 0; i < items.count(); ++i) {

    79         if (items.at(i)) {

    80             items.at(i)->d->theid = -1;

    81             items.at(i)->view = 0;

    82             delete items.at(i);

    83         }

    84     }

    85     items.clear();

    86     reset();

    87 }

    88 

    89 QListWidgetItem *QListModel::at(int row) const

    90 {

    91     return items.value(row);

    92 }

    93 

    94 void QListModel::remove(QListWidgetItem *item)

    95 {

    96     if (!item)

    97         return;

    98     int row = items.indexOf(item); // ### use index(item) - it's faster

    99     Q_ASSERT(row != -1);

   100     beginRemoveRows(QModelIndex(), row, row);

   101     items.at(row)->d->theid = -1;

   102     items.at(row)->view = 0;

   103     items.removeAt(row);

   104     endRemoveRows();

   105 }

   106 

   107 void QListModel::insert(int row, QListWidgetItem *item)

   108 {

   109     if (!item)

   110         return;

   111 

   112     item->view = qobject_cast<QListWidget*>(QObject::parent());

   113     if (item->view && item->view->isSortingEnabled()) {

   114         // sorted insertion

   115         QList<QListWidgetItem*>::iterator it;

   116         it = sortedInsertionIterator(items.begin(), items.end(),

   117                                      item->view->sortOrder(), item);

   118         row = qMax(it - items.begin(), 0);

   119     } else {

   120         if (row < 0)

   121             row = 0;

   122         else if (row > items.count())

   123             row = items.count();

   124     }

   125     beginInsertRows(QModelIndex(), row, row);

   126     items.insert(row, item);

   127     item->d->theid = row;

   128     endInsertRows();

   129 }

   130 

   131 void QListModel::insert(int row, const QStringList &labels)

   132 {

   133     const int count = labels.count();

   134     if (count <= 0)

   135         return;

   136     QListWidget *view = qobject_cast<QListWidget*>(QObject::parent());

   137     if (view && view->isSortingEnabled()) {

   138         // sorted insertion

   139         for (int i = 0; i < count; ++i) {

   140             QListWidgetItem *item = new QListWidgetItem(labels.at(i));

   141             insert(row, item);

   142         }

   143     } else {

   144         if (row < 0)

   145             row = 0;

   146         else if (row > items.count())

   147             row = items.count();

   148         beginInsertRows(QModelIndex(), row, row + count - 1);

   149         for (int i = 0; i < count; ++i) {

   150             QListWidgetItem *item = new QListWidgetItem(labels.at(i));

   151             item->d->theid = row;

   152             item->view = qobject_cast<QListWidget*>(QObject::parent());

   153             items.insert(row++, item);

   154         }

   155         endInsertRows();

   156     }

   157 }

   158 

   159 QListWidgetItem *QListModel::take(int row)

   160 {

   161     if (row < 0 || row >= items.count())

   162         return 0;

   163 

   164     beginRemoveRows(QModelIndex(), row, row);

   165     items.at(row)->d->theid = -1;

   166     items.at(row)->view = 0;

   167     QListWidgetItem *item = items.takeAt(row);

   168     endRemoveRows();

   169     return item;

   170 }

   171 

   172 void QListModel::move(int srcRow, int dstRow)

   173 {

   174     if (srcRow == dstRow

   175         || srcRow < 0 || srcRow >= items.count()

   176         || dstRow < 0 || dstRow > items.count())

   177         return;

   178 

   179     if (!beginMoveRows(QModelIndex(), srcRow, srcRow, QModelIndex(), dstRow))

   180         return;

   181     if (srcRow < dstRow)

   182         --dstRow;

   183     items.move(srcRow, dstRow);

   184     endMoveRows();

   185 }

   186 

   187 int QListModel::rowCount(const QModelIndex &parent) const

   188 {

   189     return parent.isValid() ? 0 : items.count();

   190 }

   191 

   192 QModelIndex QListModel::index(QListWidgetItem *item) const

   193 {

   194     if (!item || !item->view || static_cast<const QListModel *>(item->view->model()) != this

   195         || items.isEmpty())

   196         return QModelIndex();

   197     int row;

   198     const int theid = item->d->theid;

   199     if (theid >= 0 && theid < items.count() && items.at(theid) == item) {

   200         row = theid;

   201     } else { // we need to search for the item

   202         row = items.lastIndexOf(item);  // lastIndexOf is an optimization in favor of indexOf

   203         if (row == -1) // not found

   204             return QModelIndex();

   205         item->d->theid = row;

   206     }

   207     return createIndex(row, 0, item);

   208 }

   209 

   210 QModelIndex QListModel::index(int row, int column, const QModelIndex &parent) const

   211 {

   212     if (hasIndex(row, column, parent))

   213         return createIndex(row, column, items.at(row));

   214     return QModelIndex();

   215 }

   216 

   217 QVariant QListModel::data(const QModelIndex &index, int role) const

   218 {

   219     if (!index.isValid() || index.row() >= items.count())

   220         return QVariant();

   221     return items.at(index.row())->data(role);

   222 }

   223 

   224 bool QListModel::setData(const QModelIndex &index, const QVariant &value, int role)

   225 {

   226     if (!index.isValid() || index.row() >= items.count())

   227         return false;

   228     items.at(index.row())->setData(role, value);

   229     return true;

   230 }

   231 

   232 QMap<int, QVariant> QListModel::itemData(const QModelIndex &index) const

   233 {

   234     QMap<int, QVariant> roles;

   235     if (!index.isValid() || index.row() >= items.count())

   236         return roles;

   237     QListWidgetItem *itm = items.at(index.row());

   238     for (int i = 0; i < itm->d->values.count(); ++i) {

   239         roles.insert(itm->d->values.at(i).role,

   240                      itm->d->values.at(i).value);

   241     }

   242     return roles;

   243 }

   244 

   245 bool QListModel::insertRows(int row, int count, const QModelIndex &parent)

   246 {

   247     if (count < 1 || row < 0 || row > rowCount() || parent.isValid())

   248         return false;

   249 

   250     beginInsertRows(QModelIndex(), row, row + count - 1);

   251     QListWidget *view = qobject_cast<QListWidget*>(QObject::parent());

   252     QListWidgetItem *itm = 0;

   253 

   254     for (int r = row; r < row + count; ++r) {

   255         itm = new QListWidgetItem;

   256         itm->view = view;

   257         itm->d->theid = r;

   258         items.insert(r, itm);

   259     }

   260 

   261     endInsertRows();

   262     return true;

   263 }

   264 

   265 bool QListModel::removeRows(int row, int count, const QModelIndex &parent)

   266 {

   267     if (count < 1 || row < 0 || (row + count) > rowCount() || parent.isValid())

   268         return false;

   269 

   270     beginRemoveRows(QModelIndex(), row, row + count - 1);

   271     QListWidgetItem *itm = 0;

   272     for (int r = row; r < row + count; ++r) {

   273         itm = items.takeAt(row);

   274         itm->view = 0;

   275         itm->d->theid = -1;

   276         delete itm;

   277     }

   278     endRemoveRows();

   279     return true;

   280 }

   281 

   282 Qt::ItemFlags QListModel::flags(const QModelIndex &index) const

   283 {

   284     if (!index.isValid() || index.row() >= items.count() || index.model() != this)

   285         return Qt::ItemIsDropEnabled; // we allow drops outside the items

   286     return items.at(index.row())->flags();

   287 }

   288 

   289 void QListModel::sort(int column, Qt::SortOrder order)

   290 {

   291     if (column != 0)

   292         return;

   293 

   294     emit layoutAboutToBeChanged();

   295 

   296     QVector < QPair<QListWidgetItem*,int> > sorting(items.count());

   297     for (int i = 0; i < items.count(); ++i) {

   298         QListWidgetItem *item = items.at(i);

   299         sorting[i].first = item;

   300         sorting[i].second = i;

   301     }

   302 

   303     LessThan compare = (order == Qt::AscendingOrder ? &itemLessThan : &itemGreaterThan);

   304     qSort(sorting.begin(), sorting.end(), compare);

   305     QModelIndexList fromIndexes;

   306     QModelIndexList toIndexes;

   307     for (int r = 0; r < sorting.count(); ++r) {

   308         QListWidgetItem *item = sorting.at(r).first;

   309         toIndexes.append(createIndex(r, 0, item));

   310         fromIndexes.append(createIndex(sorting.at(r).second, 0, sorting.at(r).first));

   311         items[r] = sorting.at(r).first;

   312     }

   313     changePersistentIndexList(fromIndexes, toIndexes);

   314 

   315     emit layoutChanged();

   316 }

   317 

   318 /**

   319  * This function assumes that all items in the model except the items that are between

   320  * (inclusive) start and end are sorted.

   321  * With these assumptions, this function can ensure that the model is sorted in a

   322  * much more efficient way than doing a naive 'sort everything'.

   323  * (provided that the range is relatively small compared to the total number of items)

   324  */

   325 void QListModel::ensureSorted(int column, Qt::SortOrder order, int start, int end)

   326 {

   327     if (column != 0)

   328         return;

   329 

   330     int count = end - start + 1;

   331     QVector < QPair<QListWidgetItem*,int> > sorting(count);

   332     for (int i = 0; i < count; ++i) {

   333         sorting[i].first = items.at(start + i);

   334         sorting[i].second = start + i;

   335     }

   336 

   337     LessThan compare = (order == Qt::AscendingOrder ? &itemLessThan : &itemGreaterThan);

   338     qSort(sorting.begin(), sorting.end(), compare);

   339 

   340     QModelIndexList oldPersistentIndexes = persistentIndexList();

   341     QModelIndexList newPersistentIndexes = oldPersistentIndexes;

   342     QList<QListWidgetItem*> tmp = items;

   343     QList<QListWidgetItem*>::iterator lit = tmp.begin();

   344     bool changed = false;

   345     for (int i = 0; i < count; ++i) {

   346         int oldRow = sorting.at(i).second;

   347         QListWidgetItem *item = tmp.takeAt(oldRow);

   348         lit = sortedInsertionIterator(lit, tmp.end(), order, item);

   349         int newRow = qMax(lit - tmp.begin(), 0);

   350         lit = tmp.insert(lit, item);

   351         if (newRow != oldRow) {

   352             changed = true;

   353             for (int j = i + 1; j < count; ++j) {

   354                 int otherRow = sorting.at(j).second;

   355                 if (oldRow < otherRow && newRow >= otherRow)

   356                     --sorting[j].second;

   357                 else if (oldRow > otherRow && newRow <= otherRow)

   358                     ++sorting[j].second;

   359             }

   360             for (int k = 0; k < newPersistentIndexes.count(); ++k) {

   361                 QModelIndex pi = newPersistentIndexes.at(k);

   362                 int oldPersistentRow = pi.row();

   363                 int newPersistentRow = oldPersistentRow;

   364                 if (oldPersistentRow == oldRow)

   365                     newPersistentRow = newRow;

   366                 else if (oldRow < oldPersistentRow && newRow >= oldPersistentRow)

   367                     newPersistentRow = oldPersistentRow - 1;

   368                 else if (oldRow > oldPersistentRow && newRow <= oldPersistentRow)

   369                     newPersistentRow = oldPersistentRow + 1;

   370                 if (newPersistentRow != oldPersistentRow)

   371                     newPersistentIndexes[k] = createIndex(newPersistentRow,

   372                                                           pi.column(), pi.internalPointer());

   373             }

   374         }

   375     }

   376 

   377     if (changed) {

   378         emit layoutAboutToBeChanged();

   379         items = tmp;

   380         changePersistentIndexList(oldPersistentIndexes, newPersistentIndexes);

   381         emit layoutChanged();

   382     }

   383 }

   384 

   385 bool QListModel::itemLessThan(const QPair<QListWidgetItem*,int> &left,

   386                               const QPair<QListWidgetItem*,int> &right)

   387 {

   388     return (*left.first) < (*right.first);

   389 }

   390 

   391 bool QListModel::itemGreaterThan(const QPair<QListWidgetItem*,int> &left,

   392                                  const QPair<QListWidgetItem*,int> &right)

   393 {

   394     return (*right.first) < (*left.first);

   395 }

   396 

   397 QList<QListWidgetItem*>::iterator QListModel::sortedInsertionIterator(

   398     const QList<QListWidgetItem*>::iterator &begin,

   399     const QList<QListWidgetItem*>::iterator &end,

   400     Qt::SortOrder order, QListWidgetItem *item)

   401 {

   402     if (order == Qt::AscendingOrder)

   403         return qLowerBound(begin, end, item, QListModelLessThan());

   404     return qLowerBound(begin, end, item, QListModelGreaterThan());

   405 }

   406 

   407 void QListModel::itemChanged(QListWidgetItem *item)

   408 {

   409     QModelIndex idx = index(item);

   410     emit dataChanged(idx, idx);

   411 }

   412 

   413 QStringList QListModel::mimeTypes() const

   414 {

   415     const QListWidget *view = qobject_cast<const QListWidget*>(QObject::parent());

   416     return view->mimeTypes();

   417 }

   418 

   419 QMimeData *QListModel::internalMimeData()  const

   420 {

   421     return QAbstractItemModel::mimeData(cachedIndexes);

   422 }

   423 

   424 QMimeData *QListModel::mimeData(const QModelIndexList &indexes) const

   425 {

   426     QList<QListWidgetItem*> itemlist;

   427     for (int i = 0; i < indexes.count(); ++i)

   428         itemlist << at(indexes.at(i).row());

   429     const QListWidget *view = qobject_cast<const QListWidget*>(QObject::parent());

   430 

   431     cachedIndexes = indexes;

   432     QMimeData *mimeData = view->mimeData(itemlist);

   433     cachedIndexes.clear();

   434     return mimeData;

   435 }

   436 

   437 #ifndef QT_NO_DRAGANDDROP

   438 bool QListModel::dropMimeData(const QMimeData *data, Qt::DropAction action,

   439                               int row, int column, const QModelIndex &index)

   440 {

   441     Q_UNUSED(column);

   442     QListWidget *view = qobject_cast<QListWidget*>(QObject::parent());

   443     if (index.isValid())

   444         row = index.row();

   445     else if (row == -1)

   446         row = items.count();

   447 

   448     return view->dropMimeData(row, data, action);

   449 }

   450 

   451 Qt::DropActions QListModel::supportedDropActions() const

   452 {

   453     const QListWidget *view = qobject_cast<const QListWidget*>(QObject::parent());

   454     return view->supportedDropActions();

   455 }

   456 #endif // QT_NO_DRAGANDDROP

   457 

   458 /*!

   459     \class QListWidgetItem

   460     \brief The QListWidgetItem class provides an item for use with the

   461     QListWidget item view class.

   462 

   463     \ingroup model-view

   464 

   465     A QListWidgetItem represents a single item in a QListWidget. Each item can

   466     hold several pieces of information, and will display them appropriately.

   467 

   468     The item view convenience classes use a classic item-based interface rather

   469     than a pure model/view approach. For a more flexible list view widget,

   470     consider using the QListView class with a standard model.

   471 

   472     List items can be inserted automatically into a list, when they are

   473     constructed, by specifying the list widget:

   474 

   475     \snippet doc/src/snippets/qlistwidget-using/mainwindow.cpp 2

   476 

   477     Alternatively, list items can also be created without a parent widget, and

   478     later inserted into a list using QListWidget::insertItem().

   479 

   480     List items are typically used to display text() and an icon(). These are

   481     set with the setText() and setIcon() functions. The appearance of the text

   482     can be customized with setFont(), setForeground(), and setBackground().

   483     Text in list items can be aligned using the setTextAlignment() function.

   484     Tooltips, status tips and "What's This?" help can be added to list items

   485     with setToolTip(), setStatusTip(), and setWhatsThis().

   486 

   487     By default, items are enabled, selectable, checkable, and can be the source

   488     of drag and drop operations.

   489 

   490     Each item's flags can be changed by calling setFlags() with the appropriate

   491     value (see Qt::ItemFlags). Checkable items can be checked, unchecked and

   492     partially checked with the setCheckState() function. The corresponding

   493     checkState() function indicates the item's current check state.

   494 

   495     The isHidden() function can be used to determine whether the item is

   496     hidden. To hide an item, use setHidden().

   497 

   498 

   499     \section1 Subclassing

   500 

   501     When subclassing QListWidgetItem to provide custom items, it is possible to

   502     define new types for them enabling them to be distinguished from standard

   503     items. For subclasses that require this feature, ensure that you call the

   504     base class constructor with a new type value equal to or greater than

   505     \l UserType, within \e your constructor.

   506 

   507     \sa QListWidget, {Model/View Programming}, QTreeWidgetItem, QTableWidgetItem

   508 */

   509 

   510 /*!

   511     \enum QListWidgetItem::ItemType

   512 

   513     This enum describes the types that are used to describe list widget items.

   514 

   515     \value Type     The default type for list widget items.

   516     \value UserType The minimum value for custom types. Values below UserType are

   517                     reserved by Qt.

   518 

   519     You can define new user types in QListWidgetItem subclasses to ensure that

   520     custom items are treated specially.

   521 

   522     \sa type()

   523 */

   524 

   525 /*!

   526     \fn int QListWidgetItem::type() const

   527 

   528     Returns the type passed to the QListWidgetItem constructor.

   529 */

   530 

   531 /*!

   532     \fn QListWidget *QListWidgetItem::listWidget() const

   533 

   534     Returns the list widget containing the item.

   535 */

   536 

   537 /*!

   538     \fn void QListWidgetItem::setSelected(bool select)

   539     \since 4.2

   540 

   541     Sets the selected state of the item to \a select.

   542 

   543     \sa isSelected()

   544 */

   545 

   546 /*!

   547     \fn bool QListWidgetItem::isSelected() const

   548     \since 4.2

   549 

   550     Returns true if the item is selected; otherwise returns false.

   551 

   552     \sa setSelected()

   553 */

   554 

   555 /*!

   556     \fn void QListWidgetItem::setHidden(bool hide)

   557     \since 4.2

   558 

   559     Hides the item if \a hide is true; otherwise shows the item.

   560 

   561     \sa isHidden()

   562 */

   563 

   564 /*!

   565     \fn bool QListWidgetItem::isHidden() const

   566     \since 4.2

   567 

   568     Returns true if the item is hidden; otherwise returns false.

   569 

   570     \sa setHidden()

   571 */

   572 

   573 /*!

   574     \fn QListWidgetItem::QListWidgetItem(QListWidget *parent, int type)

   575 

   576     Constructs an empty list widget item of the specified \a type with the

   577     given \a parent. If \a parent is not specified, the item will need to be

   578     inserted into a list widget with QListWidget::insertItem().

   579 

   580     This constructor inserts the item into the model of the parent that is

   581     passed to the constructor. If the model is sorted then the behavior of the

   582     insert is undetermined since the model will call the \c '<' operator method

   583     on the item which, at this point, is not yet constructed. To avoid the

   584     undetermined behavior, we recommend not to specify the parent and use

   585     QListWidget::insertItem() instead.

   586 

   587     \sa type()

   588 */

   589 QListWidgetItem::QListWidgetItem(QListWidget *view, int type)

   590     : rtti(type), view(view), d(new QListWidgetItemPrivate(this)),

   591       itemFlags(Qt::ItemIsSelectable

   592                 |Qt::ItemIsUserCheckable

   593                 |Qt::ItemIsEnabled

   594                 |Qt::ItemIsDragEnabled)

   595 {

   596     if (QListModel *model = (view ? qobject_cast<QListModel*>(view->model()) : 0))

   597         model->insert(model->rowCount(), this);

   598 }

   599 

   600 /*!

   601     \fn QListWidgetItem::QListWidgetItem(const QString &text, QListWidget *parent, int type)

   602 

   603     Constructs an empty list widget item of the specified \a type with the

   604     given \a text and \a parent. If the parent is not specified, the item will

   605     need to be inserted into a list widget with QListWidget::insertItem().

   606 

   607     This constructor inserts the item into the model of the parent that is

   608     passed to the constructor. If the model is sorted then the behavior of the

   609     insert is undetermined since the model will call the \c '<' operator method

   610     on the item which, at this point, is not yet constructed. To avoid the

   611     undetermined behavior, we recommend not to specify the parent and use

   612     QListWidget::insertItem() instead.

   613 

   614     \sa type()

   615 */

   616 QListWidgetItem::QListWidgetItem(const QString &text, QListWidget *view, int type)

   617     : rtti(type), view(0), d(new QListWidgetItemPrivate(this)),

   618       itemFlags(Qt::ItemIsSelectable

   619                 |Qt::ItemIsUserCheckable

   620                 |Qt::ItemIsEnabled

   621                 |Qt::ItemIsDragEnabled)

   622 {

   623     setData(Qt::DisplayRole, text);

   624     this->view = view;

   625     if (QListModel *model = (view ? qobject_cast<QListModel*>(view->model()) : 0))

   626         model->insert(model->rowCount(), this);

   627 }

   628 

   629 /*!

   630     \fn QListWidgetItem::QListWidgetItem(const QIcon &icon, const QString &text, QListWidget *parent, int type)

   631 

   632     Constructs an empty list widget item of the specified \a type with the

   633     given \a icon, \a text and \a parent. If the parent is not specified, the

   634     item will need to be inserted into a list widget with

   635     QListWidget::insertItem().

   636 

   637     This constructor inserts the item into the model of the parent that is

   638     passed to the constructor. If the model is sorted then the behavior of the

   639     insert is undetermined since the model will call the \c '<' operator method

   640     on the item which, at this point, is not yet constructed. To avoid the

   641     undetermined behavior, we recommend not to specify the parent and use

   642     QListWidget::insertItem() instead.

   643 

   644     \sa type()

   645 */

   646 QListWidgetItem::QListWidgetItem(const QIcon &icon,const QString &text,

   647                                  QListWidget *view, int type)

   648     : rtti(type), view(0), d(new QListWidgetItemPrivate(this)),

   649       itemFlags(Qt::ItemIsSelectable

   650                 |Qt::ItemIsUserCheckable

   651                 |Qt::ItemIsEnabled

   652                 |Qt::ItemIsDragEnabled)

   653 {

   654     setData(Qt::DisplayRole, text);

   655     setData(Qt::DecorationRole, icon);

   656     this->view = view;

   657     if (QListModel *model = (view ? qobject_cast<QListModel*>(view->model()) : 0))

   658         model->insert(model->rowCount(), this);

   659 }

   660 

   661 /*!

   662     Destroys the list item.

   663 */

   664 QListWidgetItem::~QListWidgetItem()

   665 {

   666     if (QListModel *model = (view ? qobject_cast<QListModel*>(view->model()) : 0))

   667         model->remove(this);

   668     delete d;

   669 }

   670 

   671 /*!

   672     Creates an exact copy of the item.

   673 */

   674 QListWidgetItem *QListWidgetItem::clone() const

   675 {

   676     return new QListWidgetItem(*this);

   677 }

   678 

   679 /*!

   680     Sets the data for a given \a role to the given \a value. Reimplement this

   681     function if you need extra roles or special behavior for certain roles.

   682 

   683     \sa Qt::ItemDataRole, data()

   684 */

   685 void QListWidgetItem::setData(int role, const QVariant &value)

   686 {

   687     bool found = false;

   688     role = (role == Qt::EditRole ? Qt::DisplayRole : role);

   689     for (int i = 0; i < d->values.count(); ++i) {

   690         if (d->values.at(i).role == role) {

   691             if (d->values.at(i).value == value)

   692                 return;

   693             d->values[i].value = value;

   694             found = true;

   695             break;

   696         }

   697     }

   698     if (!found)

   699         d->values.append(QWidgetItemData(role, value));

   700     if (QListModel *model = (view ? qobject_cast<QListModel*>(view->model()) : 0))

   701         model->itemChanged(this);

   702 }

   703 

   704 /*!

   705     Returns the item's data for a given \a role. Reimplement this function if

   706     you need extra roles or special behavior for certain roles.

   707 

   708     \sa Qt::ItemDataRole, setData()

   709 */

   710 QVariant QListWidgetItem::data(int role) const

   711 {

   712     role = (role == Qt::EditRole ? Qt::DisplayRole : role);

   713     for (int i = 0; i < d->values.count(); ++i)

   714         if (d->values.at(i).role == role)

   715             return d->values.at(i).value;

   716     return QVariant();

   717 }

   718 

   719 /*!

   720     Returns true if this item's text is less then \a other item's text;

   721     otherwise returns false.

   722 */

   723 bool QListWidgetItem::operator<(const QListWidgetItem &other) const

   724 {

   725     const QVariant v1 = data(Qt::DisplayRole), v2 = other.data(Qt::DisplayRole);

   726     return QAbstractItemModelPrivate::variantLessThan(v1, v2);

   727 }

   728 

   729 #ifndef QT_NO_DATASTREAM

   730 

   731 /*!

   732     Reads the item from stream \a in.

   733 

   734     \sa write()

   735 */

   736 void QListWidgetItem::read(QDataStream &in)

   737 {

   738     in >> d->values;

   739 }

   740 

   741 /*!

   742     Writes the item to stream \a out.

   743 

   744     \sa read()

   745 */

   746 void QListWidgetItem::write(QDataStream &out) const

   747 {

   748     out << d->values;

   749 }

   750 #endif // QT_NO_DATASTREAM

   751 

   752 /*!

   753     \since 4.1

   754 

   755     Constructs a copy of \a other. Note that type() and listWidget() are not

   756     copied.

   757 

   758     This function is useful when reimplementing clone().

   759 

   760     \sa data(), flags()

   761 */

   762 QListWidgetItem::QListWidgetItem(const QListWidgetItem &other)

   763     : rtti(Type), view(0),

   764       d(new QListWidgetItemPrivate(this)),

   765       itemFlags(other.itemFlags)

   766 {

   767     d->values = other.d->values;

   768 }

   769 

   770 /*!

   771     Assigns \a other's data and flags to this item. Note that type() and

   772     listWidget() are not copied.

   773 

   774     This function is useful when reimplementing clone().

   775 

   776     \sa data(), flags()

   777 */

   778 QListWidgetItem &QListWidgetItem::operator=(const QListWidgetItem &other)

   779 {

   780     d->values = other.d->values;

   781     itemFlags = other.itemFlags;

   782     return *this;

   783 }

   784 

   785 #ifndef QT_NO_DATASTREAM

   786 

   787 /*!

   788     \relates QListWidgetItem

   789 

   790     Writes the list widget item \a item to stream \a out.

   791 

   792     This operator uses QListWidgetItem::write().

   793 

   794     \sa {Format of the QDataStream Operators}

   795 */

   796 QDataStream &operator<<(QDataStream &out, const QListWidgetItem &item)

   797 {

   798     item.write(out);

   799     return out;

   800 }

   801 

   802 /*!

   803     \relates QListWidgetItem

   804 

   805     Reads a list widget item from stream \a in into \a item.

   806 

   807     This operator uses QListWidgetItem::read().

   808 

   809     \sa {Format of the QDataStream Operators}

   810 */

   811 QDataStream &operator>>(QDataStream &in, QListWidgetItem &item)

   812 {

   813     item.read(in);

   814     return in;

   815 }

   816 

   817 #endif // QT_NO_DATASTREAM

   818 

   819 /*!

   820     \fn Qt::ItemFlags QListWidgetItem::flags() const

   821 

   822     Returns the item flags for this item (see \l{Qt::ItemFlags}).

   823 */

   824 

   825 /*!

   826     \fn QString QListWidgetItem::text() const

   827 

   828     Returns the list item's text.

   829 

   830     \sa setText()

   831 */

   832 

   833 /*!

   834     \fn QIcon QListWidgetItem::icon() const

   835 

   836     Returns the list item's icon.

   837 

   838     \sa setIcon(), {QAbstractItemView::iconSize}{iconSize}

   839 */

   840 

   841 /*!

   842     \fn QString QListWidgetItem::statusTip() const

   843 

   844     Returns the list item's status tip.

   845 

   846     \sa setStatusTip()

   847 */

   848 

   849 /*!

   850     \fn QString QListWidgetItem::toolTip() const

   851 

   852     Returns the list item's tooltip.

   853 

   854     \sa setToolTip() statusTip() whatsThis()

   855 */

   856 

   857 /*!

   858     \fn QString QListWidgetItem::whatsThis() const

   859 

   860     Returns the list item's "What's This?" help text.

   861 

   862     \sa setWhatsThis() statusTip() toolTip()

   863 */

   864 

   865 /*!

   866     \fn QFont QListWidgetItem::font() const

   867 

   868     Returns the font used to display this list item's text.

   869 */

   870 

   871 /*!

   872     \fn int QListWidgetItem::textAlignment() const

   873 

   874     Returns the text alignment for the list item.

   875 

   876     \sa Qt::AlignmentFlag

   877 */

   878 

   879 /*!

   880     \fn QColor QListWidgetItem::backgroundColor() const

   881     \obsolete

   882 

   883     This function is deprecated. Use background() instead.

   884 */

   885 

   886 /*!

   887     \fn QBrush QListWidgetItem::background() const

   888     \since 4.2

   889 

   890     Returns the brush used to display the list item's background.

   891 

   892     \sa setBackground() foreground()

   893 */

   894 

   895 /*!

   896     \fn QColor QListWidgetItem::textColor() const

   897     \obsolete

   898 

   899     Returns the color used to display the list item's text.

   900 

   901     This function is deprecated. Use foreground() instead.

   902 */

   903 

   904 /*!

   905     \fn QBrush QListWidgetItem::foreground() const

   906     \since 4.2

   907 

   908     Returns the brush used to display the list item's foreground (e.g. text).

   909 

   910     \sa setForeground() background()

   911 */

   912 

   913 /*!

   914     \fn Qt::CheckState QListWidgetItem::checkState() const

   915 

   916     Returns the checked state of the list item (see \l{Qt::CheckState}).

   917 

   918     \sa flags()

   919 */

   920 

   921 /*!

   922     \fn QSize QListWidgetItem::sizeHint() const

   923     \since 4.1

   924 

   925     Returns the size hint set for the list item.

   926 */

   927 

   928 /*!

   929     \fn void QListWidgetItem::setSizeHint(const QSize &size)

   930     \since 4.1

   931 

   932     Sets the size hint for the list item to be \a size. If no size hint is set,

   933     the item delegate will compute the size hint based on the item data.

   934 */

   935 

   936 /*!

   937     \fn void QListWidgetItem::setFlags(Qt::ItemFlags flags)

   938 

   939     Sets the item flags for the list item to \a flags.

   940 

   941     \sa Qt::ItemFlags

   942 */

   943 void QListWidgetItem::setFlags(Qt::ItemFlags aflags) {

   944     itemFlags = aflags;

   945     if (QListModel *model = (view ? qobject_cast<QListModel*>(view->model()) : 0))

   946         model->itemChanged(this);

   947 }

   948 

   949 

   950 /*!

   951     \fn void QListWidgetItem::setText(const QString &text)

   952 

   953     Sets the text for the list widget item's to the given \a text.

   954 

   955     \sa text()

   956 */

   957 

   958 /*!

   959     \fn void QListWidgetItem::setIcon(const QIcon &icon)

   960 

   961     Sets the icon for the list item to the given \a icon.

   962 

   963     \sa icon(), text(), {QAbstractItemView::iconSize}{iconSize}

   964 */

   965 

   966 /*!

   967     \fn void QListWidgetItem::setStatusTip(const QString &statusTip)

   968 

   969     Sets the status tip for the list item to the text specified by

   970     \a statusTip. QListWidget mouseTracking needs to be enabled for this

   971     feature to work.

   972 

   973     \sa statusTip(), setToolTip(), setWhatsThis(), QWidget::setMouseTracking()

   974 */

   975 

   976 /*!

   977     \fn void QListWidgetItem::setToolTip(const QString &toolTip)

   978 

   979     Sets the tooltip for the list item to the text specified by \a toolTip.

   980 

   981     \sa toolTip(), setStatusTip(), setWhatsThis()

   982 */

   983 

   984 /*!

   985     \fn void QListWidgetItem::setWhatsThis(const QString &whatsThis)

   986 

   987     Sets the "What's This?" help for the list item to the text specified by

   988     \a whatsThis.

   989 

   990     \sa whatsThis(), setStatusTip(), setToolTip()

   991 */

   992 

   993 /*!

   994     \fn void QListWidgetItem::setFont(const QFont &font)

   995 

   996     Sets the font used when painting the item to the given \a font.

   997 */

   998 

   999 /*!

  1000     \fn void QListWidgetItem::setTextAlignment(int alignment)

  1001 

  1002     Sets the list item's text alignment to \a alignment.

  1003 

  1004     \sa Qt::AlignmentFlag

  1005 */

  1006 

  1007 /*!

  1008     \fn void QListWidgetItem::setBackgroundColor(const QColor &color)

  1009     \obsolete

  1010 

  1011     This function is deprecated. Use setBackground() instead.

  1012 */

  1013 

  1014 /*!

  1015     \fn void QListWidgetItem::setBackground(const QBrush &brush)

  1016     \since 4.2

  1017 

  1018     Sets the background brush of the list item to the given \a brush.

  1019 

  1020     \sa background() setForeground()

  1021 */

  1022 

  1023 /*!

  1024     \fn void QListWidgetItem::setTextColor(const QColor &color)

  1025     \obsolete

  1026 

  1027     This function is deprecated. Use setForeground() instead.

  1028 */

  1029 

  1030 /*!

  1031     \fn void QListWidgetItem::setForeground(const QBrush &brush)

  1032     \since 4.2

  1033 

  1034     Sets the foreground brush of the list item to the given \a brush.

  1035 

  1036     \sa foreground() setBackground()

  1037 */

  1038 

  1039 /*!

  1040     \fn void QListWidgetItem::setCheckState(Qt::CheckState state)

  1041 

  1042     Sets the check state of the list item to \a state.

  1043 

  1044     \sa checkState()

  1045 */

  1046 

  1047 void QListWidgetPrivate::setup()

  1048 {

  1049     Q_Q(QListWidget);

  1050     q->QListView::setModel(new QListModel(q));

  1051     // view signals

  1052     QObject::connect(q, SIGNAL(pressed(QModelIndex)), q, SLOT(_q_emitItemPressed(QModelIndex)));

  1053     QObject::connect(q, SIGNAL(clicked(QModelIndex)), q, SLOT(_q_emitItemClicked(QModelIndex)));

  1054     QObject::connect(q, SIGNAL(doubleClicked(QModelIndex)),

  1055                      q, SLOT(_q_emitItemDoubleClicked(QModelIndex)));

  1056     QObject::connect(q, SIGNAL(activated(QModelIndex)),

  1057                      q, SLOT(_q_emitItemActivated(QModelIndex)));

  1058     QObject::connect(q, SIGNAL(entered(QModelIndex)), q, SLOT(_q_emitItemEntered(QModelIndex)));

  1059     QObject::connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),

  1060                      q, SLOT(_q_emitItemChanged(QModelIndex)));

  1061     QObject::connect(q->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),

  1062                      q, SLOT(_q_emitCurrentItemChanged(QModelIndex,QModelIndex)));

  1063     QObject::connect(q->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),

  1064                      q, SIGNAL(itemSelectionChanged()));

  1065     QObject::connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),

  1066                      q, SLOT(_q_dataChanged(QModelIndex,QModelIndex)));

  1067     QObject::connect(model, SIGNAL(columnsRemoved(QModelIndex,int,int)), q, SLOT(_q_sort()));

  1068 }

  1069 

  1070 void QListWidgetPrivate::_q_emitItemPressed(const QModelIndex &index)

  1071 {

  1072     Q_Q(QListWidget);

  1073     emit q->itemPressed(listModel()->at(index.row()));

  1074 }

  1075 

  1076 void QListWidgetPrivate::_q_emitItemClicked(const QModelIndex &index)

  1077 {

  1078     Q_Q(QListWidget);

  1079     emit q->itemClicked(listModel()->at(index.row()));

  1080 }

  1081 

  1082 void QListWidgetPrivate::_q_emitItemDoubleClicked(const QModelIndex &index)

  1083 {

  1084     Q_Q(QListWidget);

  1085     emit q->itemDoubleClicked(listModel()->at(index.row()));

  1086 }

  1087 

  1088 void QListWidgetPrivate::_q_emitItemActivated(const QModelIndex &index)

  1089 {

  1090     Q_Q(QListWidget);

  1091     emit q->itemActivated(listModel()->at(index.row()));

  1092 }

  1093 

  1094 void QListWidgetPrivate::_q_emitItemEntered(const QModelIndex &index)

  1095 {

  1096     Q_Q(QListWidget);

  1097     emit q->itemEntered(listModel()->at(index.row()));

  1098 }

  1099 

  1100 void QListWidgetPrivate::_q_emitItemChanged(const QModelIndex &index)

  1101 {

  1102     Q_Q(QListWidget);

  1103     emit q->itemChanged(listModel()->at(index.row()));

  1104 }

  1105 

  1106 void QListWidgetPrivate::_q_emitCurrentItemChanged(const QModelIndex &current,

  1107                                                 const QModelIndex &previous)

  1108 {

  1109     Q_Q(QListWidget);

  1110     QPersistentModelIndex persistentCurrent = current;

  1111     QListWidgetItem *currentItem = listModel()->at(persistentCurrent.row());

  1112     emit q->currentItemChanged(currentItem, listModel()->at(previous.row()));

  1113 

  1114     //persistentCurrent is invalid if something changed the model in response

  1115     //to the currentItemChanged signal emission and the item was removed

  1116     if (!persistentCurrent.isValid()) {

  1117         currentItem = 0;

  1118     }

  1119 

  1120     emit q->currentTextChanged(currentItem ? currentItem->text() : QString());

  1121     emit q->currentRowChanged(persistentCurrent.row());

  1122 }

  1123 

  1124 void QListWidgetPrivate::_q_sort()

  1125 {

  1126     if (sortingEnabled)

  1127         model->sort(0, sortOrder);

  1128 }

  1129 

  1130 void QListWidgetPrivate::_q_dataChanged(const QModelIndex &topLeft,

  1131                                         const QModelIndex &bottomRight)

  1132 {

  1133     if (sortingEnabled && topLeft.isValid() && bottomRight.isValid())

  1134         listModel()->ensureSorted(topLeft.column(), sortOrder,

  1135                               topLeft.row(), bottomRight.row());