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 "qtablewidget.h"

    43 

    44 #ifndef QT_NO_TABLEWIDGET

    45 #include <qitemdelegate.h>

    46 #include <qpainter.h>

    47 #include <private/qtablewidget_p.h>

    48 

    49 QT_BEGIN_NAMESPACE

    50 

    51 QTableModel::QTableModel(int rows, int columns, QTableWidget *parent)

    52     : QAbstractTableModel(parent),

    53       prototype(0),

    54       tableItems(rows * columns, 0),

    55       verticalHeaderItems(rows, 0),

    56       horizontalHeaderItems(columns, 0)

    57 {}

    58 

    59 QTableModel::~QTableModel()

    60 {

    61     clear();

    62     delete prototype;

    63 }

    64 

    65 bool QTableModel::insertRows(int row, int count, const QModelIndex &)

    66 {

    67     if (count < 1 || row < 0 || row > verticalHeaderItems.count())

    68         return false;

    69 

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

    71     int rc = verticalHeaderItems.count();

    72     int cc = horizontalHeaderItems.count();

    73     verticalHeaderItems.insert(row, count, 0);

    74     if (rc == 0)

    75         tableItems.resize(cc * count);

    76     else

    77         tableItems.insert(tableIndex(row, 0), cc * count, 0);

    78     endInsertRows();

    79     return true;

    80 }

    81 

    82 bool QTableModel::insertColumns(int column, int count, const QModelIndex &)

    83 {

    84     if (count < 1 || column < 0 || column > horizontalHeaderItems.count())

    85         return false;

    86 

    87     beginInsertColumns(QModelIndex(), column, column + count - 1);

    88     int rc = verticalHeaderItems.count();

    89     int cc = horizontalHeaderItems.count();

    90     horizontalHeaderItems.insert(column, count, 0);

    91     if (cc == 0)

    92         tableItems.resize(rc * count);

    93     else

    94         for (int row = 0; row < rc; ++row)

    95             tableItems.insert(tableIndex(row, column), count, 0);

    96     endInsertColumns();

    97     return true;

    98 }

    99 

   100 bool QTableModel::removeRows(int row, int count, const QModelIndex &)

   101 {

   102     if (count < 1 || row < 0 || row + count > verticalHeaderItems.count())

   103         return false;

   104 

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

   106     int i = tableIndex(row, 0);

   107     int n = count * columnCount();

   108     QTableWidgetItem *oldItem = 0;

   109     for (int j = i; j < n + i; ++j) {

   110         oldItem = tableItems.at(j);

   111         if (oldItem)

   112             oldItem->view = 0;

   113         delete oldItem;

   114     }

   115     tableItems.remove(qMax(i, 0), n);

   116     for (int v = row; v < row + count; ++v) {

   117         oldItem = verticalHeaderItems.at(v);

   118         if (oldItem)

   119             oldItem->view = 0;

   120         delete oldItem;

   121     }

   122     verticalHeaderItems.remove(row, count);

   123     endRemoveRows();

   124     return true;

   125 }

   126 

   127 bool QTableModel::removeColumns(int column, int count, const QModelIndex &)

   128 {

   129     if (count < 1 || column < 0 || column + count >  horizontalHeaderItems.count())

   130         return false;

   131 

   132     beginRemoveColumns(QModelIndex(), column, column + count - 1);

   133     QTableWidgetItem *oldItem = 0;

   134     for (int row = rowCount() - 1; row >= 0; --row) {

   135         int i = tableIndex(row, column);

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

   137             oldItem = tableItems.at(j);

   138             if (oldItem)

   139                 oldItem->view = 0;

   140             delete oldItem;

   141         }

   142         tableItems.remove(i, count);

   143     }

   144     for (int h=column; h<column+count; ++h) {

   145         oldItem = horizontalHeaderItems.at(h);

   146         if (oldItem)

   147             oldItem->view = 0;

   148         delete oldItem;

   149     }

   150     horizontalHeaderItems.remove(column, count);

   151     endRemoveColumns();

   152     return true;

   153 }

   154 

   155 void QTableModel::setItem(int row, int column, QTableWidgetItem *item)

   156 {

   157     int i = tableIndex(row, column);

   158     if (i < 0 || i >= tableItems.count())

   159         return;

   160     QTableWidgetItem *oldItem = tableItems.at(i);

   161     if (item == oldItem)

   162         return;

   163 

   164     // remove old

   165     if (oldItem)

   166         oldItem->view = 0;

   167     delete tableItems.at(i);

   168 

   169     QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

   170 

   171     // set new

   172     if (item)

   173         item->d->id = i;

   174     tableItems[i] = item;

   175 

   176     if (view && view->isSortingEnabled()

   177         && view->horizontalHeader()->sortIndicatorSection() == column) {

   178         // sorted insertion

   179         Qt::SortOrder order = view->horizontalHeader()->sortIndicatorOrder();

   180         QVector<QTableWidgetItem*> colItems = columnItems(column);

   181         if (row < colItems.count())

   182             colItems.remove(row);

   183         int sortedRow;

   184         if (item == 0) {

   185             // move to after all non-0 (sortable) items

   186             sortedRow = colItems.count();

   187         } else {

   188             QVector<QTableWidgetItem*>::iterator it;

   189             it = sortedInsertionIterator(colItems.begin(), colItems.end(), order, item);

   190             sortedRow = qMax((int)(it - colItems.begin()), 0);

   191         }

   192         if (sortedRow != row) {

   193             emit layoutAboutToBeChanged();

   194             // move the items @ row to sortedRow

   195             int cc = columnCount();

   196             QVector<QTableWidgetItem*> rowItems(cc);

   197             for (int j = 0; j < cc; ++j)

   198                 rowItems[j] = tableItems.at(tableIndex(row, j));

   199             tableItems.remove(tableIndex(row, 0), cc);

   200             tableItems.insert(tableIndex(sortedRow, 0), cc, 0);

   201             for (int j = 0; j < cc; ++j)

   202                 tableItems[tableIndex(sortedRow, j)] = rowItems.at(j);

   203             QTableWidgetItem *header = verticalHeaderItems.at(row);

   204             verticalHeaderItems.remove(row);

   205             verticalHeaderItems.insert(sortedRow, header);

   206             // update persistent indexes

   207             QModelIndexList oldPersistentIndexes = persistentIndexList();

   208             QModelIndexList newPersistentIndexes = oldPersistentIndexes;

   209             updateRowIndexes(newPersistentIndexes, row, sortedRow);

   210             changePersistentIndexList(oldPersistentIndexes,

   211                                       newPersistentIndexes);

   212 

   213             emit layoutChanged();

   214             return;

   215         }

   216     }

   217     QModelIndex idx = QAbstractTableModel::index(row, column);

   218     emit dataChanged(idx, idx);

   219 }

   220 

   221 QTableWidgetItem *QTableModel::takeItem(int row, int column)

   222 {

   223     long i = tableIndex(row, column);

   224     QTableWidgetItem *itm = tableItems.value(i);

   225     if (itm) {

   226         itm->view = 0;

   227         itm->d->id = -1;

   228         tableItems[i] = 0;

   229         QModelIndex ind = index(itm);

   230         emit dataChanged(ind, ind);

   231     }

   232     return itm;

   233 }

   234 

   235 QTableWidgetItem *QTableModel::item(int row, int column) const

   236 {

   237     return tableItems.value(tableIndex(row, column));

   238 }

   239 

   240 QTableWidgetItem *QTableModel::item(const QModelIndex &index) const

   241 {

   242     if (!isValid(index))

   243         return 0;

   244     return tableItems.at(tableIndex(index.row(), index.column()));

   245 }

   246 

   247 void QTableModel::removeItem(QTableWidgetItem *item)

   248 {

   249     int i = tableItems.indexOf(item);

   250     if (i != -1) {

   251         tableItems[i] = 0;

   252         QModelIndex idx = index(item);

   253         emit dataChanged(idx, idx);

   254         return;

   255     }

   256 

   257     i = verticalHeaderItems.indexOf(item);

   258 

   259     if (i != -1) {

   260         verticalHeaderItems[i] = 0;

   261         emit headerDataChanged(Qt::Vertical, i, i);

   262         return;

   263     }

   264     i = horizontalHeaderItems.indexOf(item);

   265     if (i != -1) {

   266         horizontalHeaderItems[i] = 0;

   267         emit headerDataChanged(Qt::Horizontal, i, i);

   268         return;

   269     }

   270 }

   271 

   272 void QTableModel::setHorizontalHeaderItem(int section, QTableWidgetItem *item)

   273 {

   274     if (section < 0 || section >= horizontalHeaderItems.count())

   275         return;

   276     QTableWidgetItem *oldItem = horizontalHeaderItems.at(section);

   277     if (item == oldItem)

   278         return;

   279 

   280     if (oldItem)

   281         oldItem->view = 0;

   282     delete oldItem;

   283 

   284     QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

   285 

   286     if (item) {

   287         item->view = view;

   288         item->itemFlags = Qt::ItemFlags(int(item->itemFlags)|ItemIsHeaderItem);

   289     }

   290     horizontalHeaderItems[section] = item;

   291     emit headerDataChanged(Qt::Horizontal, section, section);

   292 }

   293 

   294 void QTableModel::setVerticalHeaderItem(int section, QTableWidgetItem *item)

   295 {

   296     if (section < 0 || section >= verticalHeaderItems.count())

   297         return;

   298     QTableWidgetItem *oldItem = verticalHeaderItems.at(section);

   299     if (item == oldItem)

   300         return;

   301 

   302     if (oldItem)

   303         oldItem->view = 0;

   304     delete oldItem;

   305 

   306     QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

   307 

   308     if (item) {

   309         item->view = view;

   310         item->itemFlags = Qt::ItemFlags(int(item->itemFlags)|ItemIsHeaderItem);

   311     }

   312     verticalHeaderItems[section] = item;

   313     emit headerDataChanged(Qt::Vertical, section, section);

   314 }

   315 

   316 QTableWidgetItem *QTableModel::takeHorizontalHeaderItem(int section)

   317 {

   318     if (section < 0 || section >= horizontalHeaderItems.count())

   319         return 0;

   320     QTableWidgetItem *itm = horizontalHeaderItems.at(section);

   321     if (itm) {

   322         itm->view = 0;

   323         itm->itemFlags &= ~ItemIsHeaderItem;

   324         horizontalHeaderItems[section] = 0;

   325     }

   326     return itm;

   327 }

   328 

   329 QTableWidgetItem *QTableModel::takeVerticalHeaderItem(int section)

   330 {

   331     if (section < 0 || section >= verticalHeaderItems.count())

   332         return 0;

   333     QTableWidgetItem *itm = verticalHeaderItems.at(section);

   334     if (itm) {

   335         itm->view = 0;

   336         itm->itemFlags &= ~ItemIsHeaderItem;

   337         verticalHeaderItems[section] = 0;

   338     }

   339     return itm;

   340 }

   341 

   342 QTableWidgetItem *QTableModel::horizontalHeaderItem(int section)

   343 {

   344     return horizontalHeaderItems.value(section);

   345 }

   346 

   347 QTableWidgetItem *QTableModel::verticalHeaderItem(int section)

   348 {

   349     return verticalHeaderItems.value(section);

   350 }

   351 

   352 QModelIndex QTableModel::index(const QTableWidgetItem *item) const

   353 {

   354     if (!item)

   355         return QModelIndex();

   356     int i = -1;

   357     const int id = item->d->id;

   358     if (id >= 0 && id < tableItems.count() && tableItems.at(id) == item) {

   359         i = id;

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

   361         i = tableItems.indexOf(const_cast<QTableWidgetItem*>(item));

   362         if (i == -1) // not found

   363             return QModelIndex();

   364     }

   365     int row = i / columnCount();

   366     int col = i % columnCount();

   367     return QAbstractTableModel::index(row, col);

   368 }

   369 

   370 void QTableModel::setRowCount(int rows)

   371 {

   372     int rc = verticalHeaderItems.count();

   373     if (rows < 0 || rc == rows)

   374         return;

   375     if (rc < rows)

   376         insertRows(qMax(rc, 0), rows - rc);

   377     else

   378         removeRows(qMax(rows, 0), rc - rows);

   379 }

   380 

   381 void QTableModel::setColumnCount(int columns)

   382 {

   383     int cc = horizontalHeaderItems.count();

   384     if (columns < 0 || cc == columns)

   385         return;

   386     if (cc < columns)

   387         insertColumns(qMax(cc, 0), columns - cc);

   388     else

   389         removeColumns(qMax(columns, 0), cc - columns);

   390 }

   391 

   392 int QTableModel::rowCount(const QModelIndex &parent) const

   393 {

   394     return parent.isValid() ? 0 : verticalHeaderItems.count();

   395 }

   396 

   397 int QTableModel::columnCount(const QModelIndex &parent) const

   398 {

   399     return parent.isValid() ? 0 : horizontalHeaderItems.count();

   400 }

   401 

   402 QVariant QTableModel::data(const QModelIndex &index, int role) const

   403 {

   404     QTableWidgetItem *itm = item(index);

   405     if (itm)

   406         return itm->data(role);

   407     return QVariant();

   408 }

   409 

   410 bool QTableModel::setData(const QModelIndex &index, const QVariant &value, int role)

   411 {

   412     if (!index.isValid())

   413         return false;

   414 

   415     QTableWidgetItem *itm = item(index);

   416     if (itm) {

   417         itm->setData(role, value);

   418         return true;

   419     }

   420 

   421     // don't create dummy table items for empty values

   422     if (!value.isValid())

   423         return false;

   424 

   425     QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

   426     if (!view)

   427         return false;

   428 

   429     itm = createItem();

   430     itm->setData(role, value);

   431     view->setItem(index.row(), index.column(), itm);

   432     return true;

   433 }

   434 

   435 QMap<int, QVariant> QTableModel::itemData(const QModelIndex &index) const

   436 {

   437     QMap<int, QVariant> roles;

   438     QTableWidgetItem *itm = item(index);

   439     if (itm) {

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

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

   442                          itm->values.at(i).value);

   443         }

   444     }

   445     return roles;

   446 }

   447 

   448 // reimplemented to ensure that only one dataChanged() signal is emitted

   449 bool QTableModel::setItemData(const QModelIndex &index, const QMap<int, QVariant> &roles)

   450 {

   451     if (!index.isValid())

   452         return false;

   453 

   454     QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

   455     QTableWidgetItem *itm = item(index);

   456     if (itm) {

   457         itm->view = 0; // prohibits item from calling itemChanged()

   458         bool changed = false;

   459         for (QMap<int, QVariant>::ConstIterator it = roles.constBegin(); it != roles.constEnd(); ++it) {

   460             if (itm->data(it.key()) != it.value()) {

   461                 itm->setData(it.key(), it.value());

   462                 changed = true;

   463             }

   464         }

   465         itm->view = view;

   466         if (changed)

   467             itemChanged(itm);

   468         return true;

   469     }

   470 

   471     if (!view)

   472         return false;

   473 

   474     itm = createItem();

   475     for (QMap<int, QVariant>::ConstIterator it = roles.constBegin(); it != roles.constEnd(); ++it)

   476         itm->setData(it.key(), it.value());

   477     view->setItem(index.row(), index.column(), itm);

   478     return true;

   479 }

   480 

   481 Qt::ItemFlags QTableModel::flags(const QModelIndex &index) const

   482 {

   483     if (!index.isValid())

   484         return Qt::ItemIsDropEnabled;

   485     if (QTableWidgetItem *itm = item(index))

   486         return itm->flags();

   487     return (Qt::ItemIsEditable

   488             |Qt::ItemIsSelectable

   489             |Qt::ItemIsUserCheckable

   490             |Qt::ItemIsEnabled

   491             |Qt::ItemIsDragEnabled

   492             |Qt::ItemIsDropEnabled);

   493 }

   494 

   495 void QTableModel::sort(int column, Qt::SortOrder order)

   496 {

   497     QVector<QPair<QTableWidgetItem*, int> > sortable;

   498     QVector<int> unsortable;

   499 

   500     sortable.reserve(rowCount());

   501     unsortable.reserve(rowCount());

   502 

   503     for (int row = 0; row < rowCount(); ++row) {

   504         if (QTableWidgetItem *itm = item(row, column))

   505             sortable.append(QPair<QTableWidgetItem*,int>(itm, row));

   506         else

   507             unsortable.append(row);

   508     }

   509 

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

   511     qStableSort(sortable.begin(), sortable.end(), compare);

   512 

   513     QVector<QTableWidgetItem*> sorted_table(tableItems.count());

   514     QModelIndexList from;

   515     QModelIndexList to;

   516     for (int i = 0; i < rowCount(); ++i) {

   517         int r = (i < sortable.count()

   518                  ? sortable.at(i).second

   519                  : unsortable.at(i - sortable.count()));

   520         for (int c = 0; c < columnCount(); ++c) {

   521             sorted_table[tableIndex(i, c)] = item(r, c);

   522             from.append(createIndex(r, c, 0));

   523             to.append(createIndex(i, c, 0));

   524         }

   525     }

   526 

   527     emit layoutAboutToBeChanged();

   528 

   529     tableItems = sorted_table;

   530     changePersistentIndexList(from, to); // ### slow

   531 

   532     emit layoutChanged();

   533 }

   534 

   535 /*

   536   \internal

   537 

   538   Ensures that rows in the interval [start, end] are

   539   sorted according to the contents of column \a column

   540   and the given sort \a order.

   541 */

   542 void QTableModel::ensureSorted(int column, Qt::SortOrder order,

   543                                int start, int end)

   544 {

   545     int count = end - start + 1;

   546     QVector < QPair<QTableWidgetItem*,int> > sorting;

   547     sorting.reserve(count);

   548     for (int row = start; row <= end; ++row) {

   549         QTableWidgetItem *itm = item(row, column);

   550         if (itm == 0) {

   551             // no more sortable items (all 0-items are

   552             // at the end of the table when it is sorted)

   553             break;

   554         }

   555         sorting.append(QPair<QTableWidgetItem*,int>(itm, row));

   556     }

   557 

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

   559     qStableSort(sorting.begin(), sorting.end(), compare);

   560 

   561     QModelIndexList oldPersistentIndexes = persistentIndexList();

   562     QModelIndexList newPersistentIndexes = oldPersistentIndexes;

   563     QVector<QTableWidgetItem*> newTable = tableItems;

   564     QVector<QTableWidgetItem*> newVertical = verticalHeaderItems;

   565     QVector<QTableWidgetItem*> colItems = columnItems(column);

   566     QVector<QTableWidgetItem*>::iterator vit = colItems.begin();

   567     bool changed = false;

   568     for (int i = 0; i < sorting.count(); ++i) {

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

   570         QTableWidgetItem *item = colItems.at(oldRow);

   571         colItems.remove(oldRow);

   572         vit = sortedInsertionIterator(vit, colItems.end(), order, item);

   573         int newRow = qMax((int)(vit - colItems.begin()), 0);

   574         if ((newRow < oldRow) && !(*item < *colItems.at(oldRow - 1)) && !(*colItems.at(oldRow - 1) < *item))

   575             newRow = oldRow;

   576         vit = colItems.insert(vit, item);

   577         if (newRow != oldRow) {

   578             changed = true;

   579             // move the items @ oldRow to newRow

   580             int cc = columnCount();

   581             QVector<QTableWidgetItem*> rowItems(cc);

   582             for (int j = 0; j < cc; ++j)

   583                 rowItems[j] = newTable.at(tableIndex(oldRow, j));

   584             newTable.remove(tableIndex(oldRow, 0), cc);

   585             newTable.insert(tableIndex(newRow, 0), cc, 0);

   586             for (int j = 0; j < cc; ++j)

   587                 newTable[tableIndex(newRow, j)] = rowItems.at(j);

   588             QTableWidgetItem *header = newVertical.at(oldRow);

   589             newVertical.remove(oldRow);

   590             newVertical.insert(newRow, header);

   591             // update persistent indexes

   592             updateRowIndexes(newPersistentIndexes, oldRow, newRow);

   593             // the index of the remaining rows may have changed

   594             for (int j = i + 1; j < sorting.count(); ++j) {

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

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

   597                     --sorting[j].second;

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

   599                     ++sorting[j].second;

   600             }

   601         }

   602     }

   603 

   604     if (changed) {

   605         emit layoutAboutToBeChanged();

   606         tableItems = newTable;

   607         verticalHeaderItems = newVertical;

   608         changePersistentIndexList(oldPersistentIndexes,

   609                                   newPersistentIndexes);

   610         emit layoutChanged();

   611     }

   612 }

   613 

   614 /*

   615   \internal

   616 

   617   Returns the non-0 items in column \a column.

   618 */

   619 QVector<QTableWidgetItem*> QTableModel::columnItems(int column) const

   620 {

   621     QVector<QTableWidgetItem*> items;

   622     int rc = rowCount();

   623     items.reserve(rc);

   624     for (int row = 0; row < rc; ++row) {

   625         QTableWidgetItem *itm = item(row, column);

   626         if (itm == 0) {

   627             // no more sortable items (all 0-items are

   628             // at the end of the table when it is sorted)

   629             break;

   630         }

   631         items.append(itm);

   632     }

   633     return items;

   634 }

   635 

   636 /*

   637   \internal

   638 

   639   Adjusts the row of each index in \a indexes if necessary, given

   640   that a row of items has been moved from row \a movedFrom to row

   641   \a movedTo.

   642 */

   643 void QTableModel::updateRowIndexes(QModelIndexList &indexes,

   644                                    int movedFromRow, int movedToRow)

   645 {

   646     QModelIndexList::iterator it;

   647     for (it = indexes.begin(); it != indexes.end(); ++it) {

   648         int oldRow = (*it).row();

   649         int newRow = oldRow;

   650         if (oldRow == movedFromRow)

   651             newRow = movedToRow;

   652         else if (movedFromRow < oldRow && movedToRow >= oldRow)

   653             newRow = oldRow - 1;

   654         else if (movedFromRow > oldRow && movedToRow <= oldRow)

   655             newRow = oldRow + 1;

   656         if (newRow != oldRow)

   657             *it = index(newRow, (*it).column(), (*it).parent());

   658     }

   659 }

   660 

   661 /*

   662   \internal

   663 

   664   Returns an iterator to the item where \a item should be

   665   inserted in the interval (\a begin, \a end) according to

   666   the given sort \a order.

   667 */

   668 QVector<QTableWidgetItem*>::iterator QTableModel::sortedInsertionIterator(

   669     const QVector<QTableWidgetItem*>::iterator &begin,

   670     const QVector<QTableWidgetItem*>::iterator &end,

   671     Qt::SortOrder order, QTableWidgetItem *item)

   672 {

   673     if (order == Qt::AscendingOrder)

   674         return qLowerBound(begin, end, item, QTableModelLessThan());

   675     return qLowerBound(begin, end, item, QTableModelGreaterThan());

   676 }

   677 

   678 bool QTableModel::itemLessThan(const QPair<QTableWidgetItem*,int> &left,

   679                                const QPair<QTableWidgetItem*,int> &right)

   680 {

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

   682 }

   683 

   684 bool QTableModel::itemGreaterThan(const QPair<QTableWidgetItem*,int> &left,

   685                                   const QPair<QTableWidgetItem*,int> &right)

   686 {

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

   688 }

   689 

   690 QVariant QTableModel::headerData(int section, Qt::Orientation orientation, int role) const

   691 {

   692     if (section < 0)

   693         return QVariant();

   694 

   695     QTableWidgetItem *itm = 0;

   696     if (orientation == Qt::Horizontal && section < horizontalHeaderItems.count())

   697         itm = horizontalHeaderItems.at(section);

   698     else if (orientation == Qt::Vertical && section < verticalHeaderItems.count())

   699         itm = verticalHeaderItems.at(section);

   700     else

   701         return QVariant(); // section is out of bounds

   702 

   703     if (itm)

   704         return itm->data(role);

   705     if (role == Qt::DisplayRole)

   706         return section + 1;

   707     return QVariant();

   708 }

   709 

   710 bool QTableModel::setHeaderData(int section, Qt::Orientation orientation,

   711                                 const QVariant &value, int role)

   712 {

   713     if (section < 0 ||

   714        (orientation == Qt::Horizontal && horizontalHeaderItems.size() <= section) ||

   715        (orientation == Qt::Vertical && verticalHeaderItems.size() <= section))

   716     return false;

   717 

   718     QTableWidgetItem *itm = 0;

   719     if (orientation == Qt::Horizontal)

   720         itm = horizontalHeaderItems.at(section);

   721     else

   722         itm = verticalHeaderItems.at(section);

   723     if (itm) {

   724         itm->setData(role, value);

   725         return true;

   726     }

   727     return false;

   728 }

   729 

   730 bool QTableModel::isValid(const QModelIndex &index) const

   731 {

   732     return (index.isValid()

   733             && index.row() < verticalHeaderItems.count()

   734             && index.column() < horizontalHeaderItems.count());

   735 }

   736 

   737 void QTableModel::clear()

   738 {

   739     for (int j = 0; j < verticalHeaderItems.count(); ++j) {

   740         if (verticalHeaderItems.at(j)) {

   741             verticalHeaderItems.at(j)->view = 0;

   742             delete verticalHeaderItems.at(j);

   743             verticalHeaderItems[j] = 0;

   744         }

   745     }

   746     for (int k = 0; k < horizontalHeaderItems.count(); ++k) {

   747         if (horizontalHeaderItems.at(k)) {

   748             horizontalHeaderItems.at(k)->view = 0;

   749             delete horizontalHeaderItems.at(k);

   750             horizontalHeaderItems[k] = 0;

   751         }

   752     }

   753     clearContents();

   754 }

   755 

   756 void QTableModel::clearContents()

   757 {

   758     for (int i = 0; i < tableItems.count(); ++i) {

   759         if (tableItems.at(i)) {

   760             tableItems.at(i)->view = 0;

   761             delete tableItems.at(i);

   762             tableItems[i] = 0;

   763         }

   764     }

   765     reset();

   766 }

   767 

   768 void QTableModel::itemChanged(QTableWidgetItem *item)

   769 {

   770     if (!item)

   771         return;

   772     if (item->flags() & ItemIsHeaderItem) {

   773         int row = verticalHeaderItems.indexOf(item);

   774         if (row >= 0) {

   775             emit headerDataChanged(Qt::Vertical, row, row);

   776         } else {

   777             int column = horizontalHeaderItems.indexOf(item);

   778             if (column >= 0)

   779                 emit headerDataChanged(Qt::Horizontal, column, column);

   780         }

   781     } else {

   782         QModelIndex idx = index(item);

   783         if (idx.isValid())

   784             emit dataChanged(idx, idx);

   785     }

   786 }

   787 

   788 QTableWidgetItem* QTableModel::createItem() const

   789 {

   790     return prototype ? prototype->clone() : new QTableWidgetItem;

   791 }

   792 

   793 const QTableWidgetItem *QTableModel::itemPrototype() const

   794 {

   795     return prototype;

   796 }

   797 

   798 void QTableModel::setItemPrototype(const QTableWidgetItem *item)

   799 {

   800     if (prototype != item) {

   801         delete prototype;

   802         prototype = item;

   803     }

   804 }

   805 

   806 QStringList QTableModel::mimeTypes() const

   807 {

   808     const QTableWidget *view = qobject_cast<const QTableWidget*>(QObject::parent());

   809     return (view ? view->mimeTypes() : QStringList());

   810 }

   811 

   812 QMimeData *QTableModel::internalMimeData()  const

   813 {

   814     return QAbstractTableModel::mimeData(cachedIndexes);

   815 }

   816 

   817 QMimeData *QTableModel::mimeData(const QModelIndexList &indexes) const

   818 {

   819     QList<QTableWidgetItem*> items;

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

   821         items << item(indexes.at(i));

   822     const QTableWidget *view = qobject_cast<const QTableWidget*>(QObject::parent());

   823 

   824     // cachedIndexes is a little hack to avoid copying from QModelIndexList to

   825     // QList<QTreeWidgetItem*> and back again in the view

   826     cachedIndexes = indexes;

   827     QMimeData *mimeData = (view ? view->mimeData(items) : 0);

   828     cachedIndexes.clear();

   829     return mimeData;

   830 }

   831 

   832 bool QTableModel::dropMimeData(const QMimeData *data, Qt::DropAction action,

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

   834 {

   835     if (index.isValid()) {

   836         row = index.row();

   837         column = index.column();

   838     }else if (row == -1 || column == -1) {  // The user dropped outside the table.

   839         row = rowCount();

   840         column = 0;

   841     }

   842 

   843     QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

   844     return (view ? view->dropMimeData(row, column, data, action) : false);

   845 }

   846 

   847 Qt::DropActions QTableModel::supportedDropActions() const

   848 {

   849     const QTableWidget *view = qobject_cast<const QTableWidget*>(QObject::parent());

   850     return (view ? view->supportedDropActions() : Qt::DropActions(Qt::IgnoreAction));

   851 }

   852 

   853 /*!

   854     \class QTableWidgetSelectionRange

   855 

   856     \brief The QTableWidgetSelectionRange class provides a way to interact with

   857     selection in a model without using model indexes and a selection model.

   858 

   859     \ingroup model-view

   860 

   861     The QTableWidgetSelectionRange class stores the top left and bottom

   862     right rows and columns of a selection range in a table. The

   863     selections in the table may consist of several selection ranges.

   864 

   865     \note If the item within the selection range is marked as not selectable,

   866     e.g., \c{itemFlags() & Qt::ItemIsSelectable == 0} then it will not appear

   867     in the selection range.

   868 

   869     \sa QTableWidget

   870 */

   871 

   872 /*!

   873     Constructs an table selection range, i.e. a range

   874     whose rowCount() and columnCount() are 0.

   875 */

   876 QTableWidgetSelectionRange::QTableWidgetSelectionRange()

   877     : top(-1), left(-1), bottom(-2), right(-2)

   878 {

   879 }

   880 

   881 /*!

   882     Constructs the table selection range from the given \a top, \a

   883     left, \a bottom and \a right table rows and columns.

   884 

   885     \sa topRow(), leftColumn(), bottomRow(), rightColumn()

   886 */

   887 QTableWidgetSelectionRange::QTableWidgetSelectionRange(int top, int left, int bottom, int right)

   888     : top(top), left(left), bottom(bottom), right(right)

   889 {

   890 }

   891 

   892 /*!

   893     Constructs a the table selection range by copying the given \a

   894     other table selection range.

   895 */

   896 QTableWidgetSelectionRange::QTableWidgetSelectionRange(const QTableWidgetSelectionRange &other)

   897     : top(other.top), left(other.left), bottom(other.bottom), right(other.right)

   898 {

   899 }

   900 

   901 /*!

   902     Destroys the table selection range.

   903 */

   904 QTableWidgetSelectionRange::~QTableWidgetSelectionRange()

   905 {

   906 }

   907 

   908 /*!

   909     \fn int QTableWidgetSelectionRange::topRow() const

   910 

   911     Returns the top row of the range.

   912 

   913     \sa bottomRow(), leftColumn(), rowCount()

   914 */

   915 

   916 /*!

   917     \fn int QTableWidgetSelectionRange::bottomRow() const

   918 

   919     Returns the bottom row of the range.

   920 

   921     \sa topRow(), rightColumn(), rowCount()

   922 */

   923 

   924 /*!

   925     \fn int QTableWidgetSelectionRange::leftColumn() const

   926 

   927     Returns the left column of the range.

   928 

   929     \sa rightColumn(), topRow(), columnCount()

   930 */

   931 

   932 /*!

   933     \fn int QTableWidgetSelectionRange::rightColumn() const

   934 

   935     Returns the right column of the range.

   936 

   937     \sa leftColumn(), bottomRow(), columnCount()

   938 */

   939 

   940 /*!

   941     \since 4.1

   942     \fn int QTableWidgetSelectionRange::rowCount() const

   943 

   944     Returns the number of rows in the range.

   945 

   946     This is equivalent to bottomRow() - topRow() + 1.

   947 

   948     \sa columnCount(), topRow(), bottomRow()

   949 */

   950 

   951 /*!

   952     \since 4.1

   953     \fn int QTableWidgetSelectionRange::columnCount() const

   954 

   955     Returns the number of columns in the range.

   956 

   957     This is equivalent to rightColumn() - leftColumn() + 1.

   958 

   959     \sa rowCount(), leftColumn(), rightColumn()

   960 */

   961 

   962 /*!

   963     \class QTableWidgetItem

   964     \brief The QTableWidgetItem class provides an item for use with the

   965     QTableWidget class.

   966 

   967     \ingroup model-view

   968 

   969     Table items are used to hold pieces of information for table widgets.

   970     Items usually contain text, icons, or checkboxes

   971 

   972     The QTableWidgetItem class is a convenience class that replaces the

   973     \c QTableItem class in Qt 3. It provides an item for use with

   974     the QTableWidget class.

   975 

   976     Top-level items are constructed without a parent then inserted at the

   977     position specified by a pair of row and column numbers:

   978 

   979     \snippet doc/src/snippets/qtablewidget-using/mainwindow.cpp 3

   980 

   981     Each item can have its own background brush which is set with

   982     the setBackground() function. The current background brush can be

   983     found with background().

   984     The text label for each item can be rendered with its own font and brush.

   985     These are specified with the setFont() and setForeground() functions,

   986     and read with font() and foreground().

   987 

   988     By default, items are enabled, editable, selectable, checkable, and can be

   989     used both as the source of a drag and drop operation and as a drop target.

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

   991     value (see \l{Qt::ItemFlags}). Checkable items can be checked and unchecked

   992     with the setCheckState() function. The corresponding checkState() function

   993     indicates whether the item is currently checked.

   994 

   995     \section1 Subclassing

   996 

   997     When subclassing QTableWidgetItem to provide custom items, it is possible to

   998     define new types for them so that they can be distinguished from standard

   999     items. The constructors for subclasses that require this feature need to

  1000     call the base class constructor with a new type value equal to or greater

  1001     than \l UserType.

  1002 

  1003     \sa QTableWidget, {Model/View Programming}, QListWidgetItem, QTreeWidgetItem

  1004 */

  1005 

  1006 /*!

  1007   \fn int QTableWidgetItem::row() const

  1008   \since 4.2

  1009 

  1010   Returns the row of the item in the table.

  1011   If the item is not in a table, this function will return -1.

  1012 

  1013   \sa column()

  1014 */

  1015 

  1016 /*!

  1017   \fn int QTableWidgetItem::column() const

  1018   \since 4.2

  1019 

  1020   Returns the column of the item in the table.

  1021   If the item is not in a table, this function will return -1.

  1022 

  1023   \sa row()

  1024 */

  1025 

  1026 /*!

  1027   \fn void QTableWidgetItem::setSelected(bool select)

  1028   \since 4.2

  1029 

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

  1031 

  1032   \sa isSelected()

  1033 */

  1034 

  1035 /*!

  1036   \fn bool QTableWidgetItem::isSelected() const

  1037   \since 4.2

  1038 

  1039   Returns true if the item is selected, otherwise returns false.

  1040 

  1041   \sa setSelected()

  1042 */

  1043 

  1044 /*!

  1045   \fn QSize QTableWidgetItem::sizeHint() const

  1046   \since 4.1

  1047 

  1048   Returns the size hint set for the table item.

  1049 */

  1050 

  1051 /*!

  1052   \fn void QTableWidgetItem::setSizeHint(const QSize &size)

  1053   \since 4.1

  1054 

  1055   Sets the size hint for the table item to be \a size.

  1056   If no size hint is set, the item delegate will compute the

  1057   size hint based on the item data.

  1058 */

  1059 

  1060 /*!

  1061     \fn Qt::CheckState QTableWidgetItem::checkState() const

  1062 

  1063     Returns the checked state of the table item.

  1064 

  1065     \sa flags()

  1066 */

  1067 

  1068 /*!

  1069     \fn void QTableWidgetItem::setCheckState(Qt::CheckState state)

  1070 

  1071     Sets the check state of the table item to be \a state.

  1072 */

  1073 

  1074 /*!

  1075     \fn QTableWidget *QTableWidgetItem::tableWidget() const

  1076 

  1077     Returns the table widget that contains the item.

  1078 */

  1079 

  1080 /*!

  1081     \fn Qt::ItemFlags QTableWidgetItem::flags() const

  1082 

  1083     Returns the flags used to describe the item. These determine whether

  1084     the item can be checked, edited, and selected.

  1085 

  1086     \sa setFlags()

  1087 */

  1088 

  1089 /*!

  1090     \fn void QTableWidgetItem::setFlags(Qt::ItemFlags flags)

  1091 

  1092     Sets the flags for the item to the given \a flags. These determine whether

  1093     the item can be selected or modified.

  1094 

  1095     \sa flags()

  1096 */

  1097 void QTableWidgetItem::setFlags(Qt::ItemFlags aflags)

  1098 {

  1099     itemFlags = aflags;

  1100     if (QTableModel *model = (view ? qobject_cast<QTableModel*>(view->model()) : 0))

  1101         model->itemChanged(this);

  1102 }

  1103 

  1104 

  1105 /*!

  1106     \fn QString QTableWidgetItem::text() const

  1107 

  1108     Returns the item's text.

  1109 

  1110     \sa setText()

  1111 */

  1112 

  1113 /*!

  1114     \fn void QTableWidgetItem::setText(const QString &text)

  1115 

  1116     Sets the item's text to the \a text specified.

  1117 

  1118     \sa text() setFont() setForeground()

  1119 */

  1120 

  1121 /*!

  1122     \fn QIcon QTableWidgetItem::icon() const

  1123 

  1124     Returns the item's icon.

  1125 

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

  1127 */

  1128 

  1129 /*!

  1130     \fn void QTableWidgetItem::setIcon(const QIcon &icon)

  1131 

  1132     Sets the item's icon to the \a icon specified.

  1133 

  1134     \sa icon(), setText(), {QAbstractItemView::iconSize}{iconSize}