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

     2 **

     3 ** Copyright (C) 2009 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 int QListModel::rowCount(const QModelIndex &parent) const

   173 {

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

   175 }

   176 

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

   178 {

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

   180         || items.isEmpty())

   181         return QModelIndex();

   182     int row;

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

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

   185         row = theid;

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

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

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

   189             return QModelIndex();

   190         item->d->theid = row;

   191     }

   192     return createIndex(row, 0, item);

   193 }

   194 

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

   196 {

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

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

   199     return QModelIndex();

   200 }

   201 

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

   203 {

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

   205         return QVariant();

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

   207 }

   208 

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

   210 {

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

   212         return false;

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

   214     return true;

   215 }

   216 

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

   218 {

   219     QMap<int, QVariant> roles;

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

   221         return roles;

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

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

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

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

   226     }

   227     return roles;

   228 }

   229 

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

   231 {

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

   233         return false;

   234 

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

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

   237     QListWidgetItem *itm = 0;

   238 

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

   240         itm = new QListWidgetItem;

   241         itm->view = view;

   242         itm->d->theid = r;

   243         items.insert(r, itm);

   244     }

   245 

   246     endInsertRows();

   247     return true;

   248 }

   249 

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

   251 {

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

   253         return false;

   254 

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

   256     QListWidgetItem *itm = 0;

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

   258         itm = items.takeAt(row);

   259         itm->view = 0;

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

   261         delete itm;

   262     }

   263     endRemoveRows();

   264     return true;

   265 }

   266 

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

   268 {

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

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

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

   272 }

   273 

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

   275 {

   276     if (column != 0)

   277         return;

   278 

   279     emit layoutAboutToBeChanged();

   280 

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

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

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

   284         sorting[i].first = item;

   285         sorting[i].second = i;

   286     }

   287 

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

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

   290     QModelIndexList fromIndexes;

   291     QModelIndexList toIndexes;

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

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

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

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

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

   297     }

   298     changePersistentIndexList(fromIndexes, toIndexes);

   299 

   300     emit layoutChanged();

   301 }

   302 

   303 /**

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

   305  * (inclusive) start and end are sorted.

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

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

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

   309  */

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

   311 {

   312     if (column != 0)

   313         return;

   314 

   315     int count = end - start + 1;

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

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

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

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

   320     }

   321 

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

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

   324 

   325     QModelIndexList oldPersistentIndexes = persistentIndexList();

   326     QModelIndexList newPersistentIndexes = oldPersistentIndexes;

   327     QList<QListWidgetItem*> tmp = items;

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

   329     bool changed = false;

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

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

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

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

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

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

   336         if (newRow != oldRow) {

   337             changed = true;

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

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

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

   341                     --sorting[j].second;

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

   343                     ++sorting[j].second;

   344             }

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

   346                 QModelIndex pi = newPersistentIndexes.at(k);

   347                 int oldPersistentRow = pi.row();

   348                 int newPersistentRow = oldPersistentRow;

   349                 if (oldPersistentRow == oldRow)

   350                     newPersistentRow = newRow;

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

   352                     newPersistentRow = oldPersistentRow - 1;

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

   354                     newPersistentRow = oldPersistentRow + 1;

   355                 if (newPersistentRow != oldPersistentRow)

   356                     newPersistentIndexes[k] = createIndex(newPersistentRow,

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

   358             }

   359         }

   360     }

   361 

   362     if (changed) {

   363         emit layoutAboutToBeChanged();

   364         items = tmp;

   365         changePersistentIndexList(oldPersistentIndexes, newPersistentIndexes);

   366         emit layoutChanged();

   367     }

   368 }

   369 

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

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

   372 {

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

   374 }

   375 

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

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

   378 {

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

   380 }

   381 

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

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

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

   385     Qt::SortOrder order, QListWidgetItem *item)

   386 {

   387     if (order == Qt::AscendingOrder)

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

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

   390 }

   391 

   392 void QListModel::itemChanged(QListWidgetItem *item)

   393 {

   394     QModelIndex idx = index(item);

   395     emit dataChanged(idx, idx);

   396 }

   397 

   398 QStringList QListModel::mimeTypes() const

   399 {

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

   401     return view->mimeTypes();

   402 }

   403 

   404 QMimeData *QListModel::internalMimeData()  const

   405 {

   406     return QAbstractItemModel::mimeData(cachedIndexes);

   407 }

   408 

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

   410 {

   411     QList<QListWidgetItem*> itemlist;

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

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

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

   415 

   416     cachedIndexes = indexes;

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

   418     cachedIndexes.clear();

   419     return mimeData;

   420 }

   421 

   422 #ifndef QT_NO_DRAGANDDROP

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

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

   425 {

   426     Q_UNUSED(column);

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

   428     if (index.isValid())

   429         row = index.row();

   430     else if (row == -1)

   431         row = items.count();

   432 

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

   434 }

   435 

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

   437 {

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

   439     return view->supportedDropActions();

   440 }

   441 #endif // QT_NO_DRAGANDDROP

   442 

   443 /*!

   444     \class QListWidgetItem

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

   446     QListWidget item view class.

   447 

   448     \ingroup model-view

   449 

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

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

   452 

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

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

   455     consider using the QListView class with a standard model.

   456 

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

   458     constructed, by specifying the list widget:

   459 

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

   461 

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

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

   464 

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

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

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

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

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

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

   471 

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

   473     of drag and drop operations.

   474 

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

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

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

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

   479 

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

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

   482 

   483 

   484     \section1 Subclassing

   485 

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

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

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

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

   490     \l UserType, within \e your constructor.

   491 

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

   493 */

   494 

   495 /*!

   496     \enum QListWidgetItem::ItemType

   497 

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

   499 

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

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

   502                     reserved by Qt.

   503 

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

   505     custom items are treated specially.

   506 

   507     \sa type()

   508 */

   509 

   510 /*!

   511     \fn int QListWidgetItem::type() const

   512 

   513     Returns the type passed to the QListWidgetItem constructor.

   514 */

   515 

   516 /*!

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

   518 

   519     Returns the list widget containing the item.

   520 */

   521 

   522 /*!

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

   524     \since 4.2

   525 

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

   527 

   528     \sa isSelected()

   529 */

   530 

   531 /*!

   532     \fn bool QListWidgetItem::isSelected() const

   533     \since 4.2

   534 

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

   536 

   537     \sa setSelected()

   538 */

   539 

   540 /*!

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

   542     \since 4.2

   543 

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

   545 

   546     \sa isHidden()

   547 */

   548 

   549 /*!

   550     \fn bool QListWidgetItem::isHidden() const

   551     \since 4.2

   552 

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

   554 

   555     \sa setHidden()

   556 */

   557 

   558 /*!

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

   560 

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

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

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

   564 

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

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

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

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

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

   570     QListWidget::insertItem() instead.

   571 

   572     \sa type()

   573 */

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

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

   576       itemFlags(Qt::ItemIsSelectable

   577                 |Qt::ItemIsUserCheckable

   578                 |Qt::ItemIsEnabled

   579                 |Qt::ItemIsDragEnabled)

   580 {

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

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

   583 }

   584 

   585 /*!

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

   587 

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

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

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

   591 

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

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

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

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

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

   597     QListWidget::insertItem() instead.

   598 

   599     \sa type()

   600 */

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

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

   603       itemFlags(Qt::ItemIsSelectable

   604                 |Qt::ItemIsUserCheckable

   605                 |Qt::ItemIsEnabled

   606                 |Qt::ItemIsDragEnabled)

   607 {

   608     setData(Qt::DisplayRole, text);

   609     this->view = view;

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

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

   612 }

   613 

   614 /*!

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

   616 

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

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

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

   620     QListWidget::insertItem().

   621 

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

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

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

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

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

   627     QListWidget::insertItem() instead.

   628 

   629     \sa type()

   630 */

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

   632                                  QListWidget *view, int type)

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

   634       itemFlags(Qt::ItemIsSelectable

   635                 |Qt::ItemIsUserCheckable

   636                 |Qt::ItemIsEnabled

   637                 |Qt::ItemIsDragEnabled)

   638 {

   639     setData(Qt::DisplayRole, text);

   640     setData(Qt::DecorationRole, icon);

   641     this->view = view;

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

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

   644 }

   645 

   646 /*!

   647     Destroys the list item.

   648 */

   649 QListWidgetItem::~QListWidgetItem()

   650 {

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

   652         model->remove(this);

   653     delete d;

   654 }

   655 

   656 /*!

   657     Creates an exact copy of the item.

   658 */

   659 QListWidgetItem *QListWidgetItem::clone() const

   660 {

   661     return new QListWidgetItem(*this);

   662 }

   663 

   664 /*!

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

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

   667 

   668     \sa Qt::ItemDataRole, data()

   669 */

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

   671 {

   672     bool found = false;

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

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

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

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

   677                 return;

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

   679             found = true;

   680             break;

   681         }

   682     }

   683     if (!found)

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

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

   686         model->itemChanged(this);

   687 }

   688 

   689 /*!

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

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

   692 

   693     \sa Qt::ItemDataRole, setData()

   694 */

   695 QVariant QListWidgetItem::data(int role) const

   696 {

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

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

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

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

   701     return QVariant();

   702 }

   703 

   704 /*!

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

   706     otherwise returns false.

   707 */

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

   709 {

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

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

   712 }

   713 

   714 #ifndef QT_NO_DATASTREAM

   715 

   716 /*!

   717     Reads the item from stream \a in.

   718 

   719     \sa write()

   720 */

   721 void QListWidgetItem::read(QDataStream &in)

   722 {

   723     in >> d->values;

   724 }

   725 

   726 /*!

   727     Writes the item to stream \a out.

   728 

   729     \sa read()

   730 */

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

   732 {

   733     out << d->values;

   734 }

   735 #endif // QT_NO_DATASTREAM

   736 

   737 /*!

   738     \since 4.1

   739 

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

   741     copied.

   742 

   743     This function is useful when reimplementing clone().

   744 

   745     \sa data(), flags()

   746 */

   747 QListWidgetItem::QListWidgetItem(const QListWidgetItem &other)

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

   749       d(new QListWidgetItemPrivate(this)),

   750       itemFlags(other.itemFlags)

   751 {

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

   753 }

   754 

   755 /*!

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

   757     listWidget() are not copied.

   758 

   759     This function is useful when reimplementing clone().

   760 

   761     \sa data(), flags()

   762 */

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

   764 {

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

   766     itemFlags = other.itemFlags;

   767     return *this;

   768 }

   769 

   770 #ifndef QT_NO_DATASTREAM

   771 

   772 /*!

   773     \relates QListWidgetItem

   774 

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

   776 

   777     This operator uses QListWidgetItem::write().

   778 

   779     \sa {Format of the QDataStream Operators}

   780 */

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

   782 {

   783     item.write(out);

   784     return out;

   785 }

   786 

   787 /*!

   788     \relates QListWidgetItem

   789 

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

   791 

   792     This operator uses QListWidgetItem::read().

   793 

   794     \sa {Format of the QDataStream Operators}

   795 */

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

   797 {

   798     item.read(in);

   799     return in;

   800 }

   801 

   802 #endif // QT_NO_DATASTREAM

   803 

   804 /*!

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

   806 

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

   808 */

   809 

   810 /*!

   811     \fn QString QListWidgetItem::text() const

   812 

   813     Returns the list item's text.

   814 

   815     \sa setText()

   816 */

   817 

   818 /*!

   819     \fn QIcon QListWidgetItem::icon() const

   820 

   821     Returns the list item's icon.

   822 

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

   824 */

   825 

   826 /*!

   827     \fn QString QListWidgetItem::statusTip() const

   828 

   829     Returns the list item's status tip.

   830 

   831     \sa setStatusTip()

   832 */

   833 

   834 /*!

   835     \fn QString QListWidgetItem::toolTip() const

   836 

   837     Returns the list item's tooltip.

   838 

   839     \sa setToolTip() statusTip() whatsThis()

   840 */

   841 

   842 /*!

   843     \fn QString QListWidgetItem::whatsThis() const

   844 

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

   846 

   847     \sa setWhatsThis() statusTip() toolTip()

   848 */

   849 

   850 /*!

   851     \fn QFont QListWidgetItem::font() const

   852 

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

   854 */

   855 

   856 /*!

   857     \fn int QListWidgetItem::textAlignment() const

   858 

   859     Returns the text alignment for the list item.

   860 

   861     \sa Qt::AlignmentFlag

   862 */

   863 

   864 /*!

   865     \fn QColor QListWidgetItem::backgroundColor() const

   866     \obsolete

   867 

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

   869 */

   870 

   871 /*!

   872     \fn QBrush QListWidgetItem::background() const

   873     \since 4.2

   874 

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

   876 

   877     \sa setBackground() foreground()

   878 */

   879 

   880 /*!

   881     \fn QColor QListWidgetItem::textColor() const

   882     \obsolete

   883 

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

   885 

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

   887 */

   888 

   889 /*!

   890     \fn QBrush QListWidgetItem::foreground() const

   891     \since 4.2

   892 

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

   894 

   895     \sa setForeground() background()

   896 */

   897 

   898 /*!

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

   900 

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

   902 

   903     \sa flags()

   904 */

   905 

   906 /*!

   907     \fn QSize QListWidgetItem::sizeHint() const

   908     \since 4.1

   909 

   910     Returns the size hint set for the list item.

   911 */

   912 

   913 /*!

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

   915     \since 4.1

   916 

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

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

   919 */

   920 

   921 /*!

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

   923 

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

   925 

   926     \sa Qt::ItemFlags

   927 */

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

   929     itemFlags = aflags;

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

   931         model->itemChanged(this);

   932 }

   933 

   934 

   935 /*!

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

   937 

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

   939 

   940     \sa text()

   941 */

   942 

   943 /*!

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

   945 

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

   947 

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

   949 */

   950 

   951 /*!

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

   953 

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

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

   956     feature to work.

   957 

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

   959 */

   960 

   961 /*!

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

   963 

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

   965 

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

   967 */

   968 

   969 /*!

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

   971 

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

   973     \a whatsThis.

   974 

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

   976 */

   977 

   978 /*!

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

   980 

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

   982 */

   983 

   984 /*!

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

   986 

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

   988 

   989     \sa Qt::AlignmentFlag

   990 */

   991 

   992 /*!

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

   994     \obsolete

   995 

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

   997 */

   998 

   999 /*!

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

  1001     \since 4.2

  1002 

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

  1004 

  1005     \sa background() setForeground()

  1006 */

  1007 

  1008 /*!

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

  1010     \obsolete

  1011 

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

  1013 */

  1014 

  1015 /*!

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

  1017     \since 4.2

  1018 

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

  1020 

  1021     \sa foreground() setBackground()

  1022 */

  1023 

  1024 /*!

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

  1026 

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

  1028 

  1029     \sa checkState()

  1030 */

  1031 

  1032 void QListWidgetPrivate::setup()

  1033 {

  1034     Q_Q(QListWidget);

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

  1036     // view signals

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

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

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

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

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

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

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

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

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

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

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

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

  1049                      q, SIGNAL(itemSelectionChanged()));

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

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

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

  1053 }

  1054 

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

  1056 {

  1057     Q_Q(QListWidget);

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

  1059 }

  1060 

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

  1062 {

  1063     Q_Q(QListWidget);

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

  1065 }

  1066 

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

  1068 {

  1069     Q_Q(QListWidget);

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

  1071 }

  1072 

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

  1074 {

  1075     Q_Q(QListWidget);

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

  1077 }

  1078 

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

  1080 {

  1081     Q_Q(QListWidget);

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

  1083 }

  1084 

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

  1086 {

  1087     Q_Q(QListWidget);

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

  1089 }

  1090 

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

  1092                                                 const QModelIndex &previous)

  1093 {

  1094     Q_Q(QListWidget);

  1095     QPersistentModelIndex persistentCurrent = current;

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

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

  1098 

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

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

  1101     if (!persistentCurrent.isValid()) {

  1102         currentItem = 0;

  1103     }

  1104 

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

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

  1107 }

  1108 

  1109 void QListWidgetPrivate::_q_sort()

  1110 {

  1111     if (sortingEnabled)

  1112         model->sort(0, sortOrder);

  1113 }

  1114 

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

  1116                                         const QModelIndex &bottomRight)

  1117 {

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

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

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

  1121 }

  1122 

  1123 /*!

  1124     \class QListWidget

  1125     \brief The QListWidget class provides an item-based list widget.

  1126 

  1127     \ingroup model-view

  1128 

  1129 

  1130     QListWidget is a convenience class that provides a list view similar to the

  1131     one supplied by QListView, but with a classic item-based interface for

  1132     adding and removing items. QListWidget uses an internal model to manage

  1133     each QListWidgetItem in the list.

  1134