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 test suite 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 

    43 

    44 #include <qabstractitemview.h>

    45 

    46 #include <QtTest/QtTest>

    47 #include <QtGui/QtGui>

    48 #include "../../shared/util.h"

    49 

    50 //TESTED_CLASS=

    51 //TESTED_FILES=

    52 

    53 Q_DECLARE_METATYPE(QModelIndex)

    54 #ifndef QT_NO_DRAGANDDROP

    55 Q_DECLARE_METATYPE(QAbstractItemView::DragDropMode)

    56 #endif

    57 Q_DECLARE_METATYPE(QAbstractItemView::EditTriggers)

    58 Q_DECLARE_METATYPE(QAbstractItemView::EditTrigger)

    59 

    60 static void initStandardTreeModel(QStandardItemModel *model)

    61 {

    62     QStandardItem *item;

    63     item = new QStandardItem(QLatin1String("Row 1 Item"));

    64     model->insertRow(0, item);

    65 

    66     item = new QStandardItem(QLatin1String("Row 2 Item"));

    67     item->setCheckable(true);

    68     model->insertRow(1, item);

    69 

    70     QStandardItem *childItem = new QStandardItem(QLatin1String("Row 2 Child Item"));

    71     item->setChild(0, childItem);

    72 

    73     item = new QStandardItem(QLatin1String("Row 3 Item"));

    74     item->setIcon(QIcon());

    75     model->insertRow(2, item);

    76 }

    77 

    78 struct PublicView : public QTreeView

    79 {

    80     inline void executeDelayedItemsLayout()

    81     { QTreeView::executeDelayedItemsLayout(); }

    82 

    83     enum PublicCursorAction {

    84         MoveUp = QAbstractItemView::MoveUp,

    85         MoveDown = QAbstractItemView::MoveDown,

    86         MoveLeft = QAbstractItemView::MoveLeft,

    87         MoveRight = QAbstractItemView::MoveRight,

    88         MoveHome = QAbstractItemView::MoveHome,

    89         MoveEnd = QAbstractItemView::MoveEnd,

    90         MovePageUp = QAbstractItemView::MovePageUp,

    91         MovePageDown = QAbstractItemView::MovePageDown,

    92         MoveNext = QAbstractItemView::MoveNext,

    93         MovePrevious = QAbstractItemView::MovePrevious

    94     };

    95 

    96     inline QModelIndex moveCursor(PublicCursorAction ca, Qt::KeyboardModifiers kbm)

    97     { return QTreeView::moveCursor((CursorAction)ca, kbm); }

    98 

    99     inline void setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command)

   100     {

   101         QTreeView::setSelection(rect, command);

   102     }

   103     inline int state()

   104     {

   105         return QTreeView::state();

   106     }

   107 

   108     inline int rowHeight(QModelIndex idx) { return QTreeView::rowHeight(idx); }

   109     inline int indexRowSizeHint(const QModelIndex &index) const { return QTreeView::indexRowSizeHint(index); }

   110 

   111     inline QModelIndexList selectedIndexes() const { return QTreeView::selectedIndexes(); }

   112 

   113     inline QStyleOptionViewItem viewOptions() const { return QTreeView::viewOptions(); }

   114     inline int sizeHintForColumn(int column) const { return QTreeView::sizeHintForColumn(column); }

   115 };

   116 

   117 class tst_QTreeView : public QObject

   118 {

   119     Q_OBJECT

   120 

   121 public:

   122     tst_QTreeView();

   123     virtual ~tst_QTreeView();

   124 

   125 

   126 public slots:

   127     void initTestCase();

   128     void cleanupTestCase();

   129     void init();

   130     void cleanup();

   131 

   132     void selectionOrderTest();

   133 

   134 private slots:

   135     void getSetCheck();

   136 

   137     // one test per QTreeView property

   138     void construction();

   139     void alternatingRowColors();

   140     void currentIndex_data();

   141     void currentIndex();

   142 #ifndef QT_NO_DRAGANDDROP

   143     void dragDropMode_data();

   144     void dragDropMode();

   145     void dragDropModeFromDragEnabledAndAcceptDrops_data();

   146     void dragDropModeFromDragEnabledAndAcceptDrops();

   147     void dragDropOverwriteMode();

   148 #endif

   149     void editTriggers_data();

   150     void editTriggers();

   151     void hasAutoScroll();

   152     void horizontalScrollMode();

   153     void iconSize();

   154     void indexAt();

   155     void indexWidget();

   156     void itemDelegate();

   157     void itemDelegateForColumnOrRow();

   158     void keyboardSearch();

   159     void setModel();

   160     void openPersistentEditor();

   161     void rootIndex();

   162 

   163     // specialized tests below

   164     void setHeader();

   165     void columnHidden();

   166     void rowHidden();

   167     void noDelegate();

   168     void noModel();

   169     void emptyModel();

   170     void removeRows();

   171     void removeCols();

   172     void expandAndCollapse_data();

   173     void expandAndCollapse();

   174     void expandAndCollapseAll();

   175     void expandWithNoChildren();

   176     void keyboardNavigation();

   177     void headerSections();

   178     void moveCursor_data();

   179     void moveCursor();

   180     void setSelection_data();

   181     void setSelection();

   182     void extendedSelection_data();

   183     void extendedSelection();

   184     void indexAbove();

   185     void indexBelow();

   186     void clicked();

   187     void mouseDoubleClick();

   188     void rowsAboutToBeRemoved();

   189     void headerSections_unhideSection();

   190     void columnAt();

   191     void scrollTo();

   192     void rowsAboutToBeRemoved_move();

   193     void resizeColumnToContents();

   194     void insertAfterSelect();

   195     void removeAfterSelect();

   196     void hiddenItems();

   197     void spanningItems();

   198     void rowSizeHint();

   199     void setSortingEnabled();

   200     void headerHidden();

   201 

   202     void selection();

   203     void removeAndInsertExpandedCol0();

   204     void selectionWithHiddenItems();

   205     void selectAll();

   206 

   207     void disabledButCheckable();

   208     void sortByColumn_data();

   209     void sortByColumn();

   210 

   211     void evilModel_data();

   212     void evilModel();

   213 

   214     void indexRowSizeHint();

   215     void addRowsWhileSectionsAreHidden();

   216     void filterProxyModelCrash();

   217     void styleOptionViewItem();

   218 

   219     // task-specific tests:

   220     void task174627_moveLeftToRoot();

   221     void task171902_expandWith1stColHidden();

   222     void task203696_hidingColumnsAndRowsn();

   223     void task211293_removeRootIndex();

   224     void task216717_updateChildren();

   225     void task220298_selectColumns();

   226     void task224091_appendColumns();

   227     void task225539_deleteModel();

   228     void task230123_setItemsExpandable();

   229     void task202039_closePersistentEditor();

   230     void task238873_avoidAutoReopening();

   231     void task244304_clickOnDecoration();

   232     void task246536_scrollbarsNotWorking();

   233     void task250683_wrongSectionSize();

   234     void task239271_addRowsWithFirstColumnHidden();

   235     void task254234_proxySort();

   236     void task248022_changeSelection();

   237     void task245654_changeModelAndExpandAll();

   238 };

   239 

   240 class QtTestModel: public QAbstractItemModel

   241 {

   242 public:

   243     QtTestModel(QObject *parent = 0): QAbstractItemModel(parent),

   244        fetched(false), rows(0), cols(0), levels(INT_MAX), wrongIndex(false) { init(); }

   245 

   246     QtTestModel(int _rows, int _cols, QObject *parent = 0): QAbstractItemModel(parent),

   247        rows(_rows), cols(_cols), levels(INT_MAX), wrongIndex(false) { init(); }

   248 

   249     void init() {

   250         decorationsEnabled = false;

   251     }

   252 

   253     inline qint32 level(const QModelIndex &index) const {

   254         return index.isValid() ? qint32(index.internalId()) : qint32(-1);

   255     }

   256 

   257     bool canFetchMore(const QModelIndex &) const {

   258         return !fetched;

   259     }

   260 

   261     void fetchMore(const QModelIndex &) {

   262         fetched = true;

   263     }

   264 

   265     bool hasChildren(const QModelIndex &parent = QModelIndex()) const {

   266         bool hasFetched = fetched;

   267         fetched = true;

   268         bool r = QAbstractItemModel::hasChildren(parent);

   269         fetched = hasFetched;

   270         return r;

   271     }

   272 

   273     int rowCount(const QModelIndex& parent = QModelIndex()) const {

   274         Q_ASSERT(fetched);

   275         if ((parent.column() > 0) || (level(parent) > levels))

   276             return 0;

   277         return rows;

   278     }

   279     int columnCount(const QModelIndex& parent = QModelIndex()) const {

   280         if ((parent.column() > 0) || (level(parent) > levels))

   281             return 0;

   282         return cols;

   283     }

   284 

   285     bool isEditable(const QModelIndex &index) const {

   286         if (index.isValid())

   287             return true;

   288         return false;

   289     }

   290 

   291     QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const

   292     {

   293         if (row < 0 || column < 0 || (level(parent) > levels) || column >= cols || row >= rows) {

   294             return QModelIndex();

   295         }

   296         QModelIndex i = createIndex(row, column, level(parent) + 1);

   297         parentHash[i] = parent;

   298         return i;

   299     }

   300 

   301     QModelIndex parent(const QModelIndex &index) const

   302     {

   303         if (!parentHash.contains(index))

   304             return QModelIndex();

   305         return parentHash[index];

   306     }

   307 

   308     QVariant data(const QModelIndex &idx, int role) const

   309     {

   310         if (!idx.isValid())

   311             return QVariant();

   312 

   313         if (role == Qt::DisplayRole) {

   314             if (idx.row() < 0 || idx.column() < 0 || idx.column() >= cols || idx.row() >= rows) {

   315                 wrongIndex = true;

   316                 qWarning("Invalid modelIndex [%d,%d,%p]", idx.row(), idx.column(),

   317                          idx.internalPointer());

   318             }

   319             if (idx.row() & 1)

   320                 return QString("[%1,%2,%3] - this item is extra wide").arg(idx.row()).arg(idx.column()).arg(level(idx));

   321             return QString("[%1,%2,%3]").arg(idx.row()).arg(idx.column()).arg(level(idx));

   322         }

   323         if (decorationsEnabled && role == Qt::DecorationRole) {

   324             QPixmap pm(16,16);

   325             pm.fill(QColor::fromHsv((idx.column() % 16)*8 + 64, 254, (idx.row() % 16)*8 + 32));

   326             return pm;

   327         }

   328         return QVariant();

   329     }

   330 

   331     void removeLastRow()

   332     {

   333         beginRemoveRows(QModelIndex(), rows - 1, rows - 1);

   334         --rows;

   335         endRemoveRows();

   336     }

   337 

   338     void removeAllRows()

   339     {

   340         beginRemoveRows(QModelIndex(), 0, rows - 1);

   341         rows = 0;

   342         endRemoveRows();

   343     }

   344 

   345     void removeLastColumn()

   346     {

   347         beginRemoveColumns(QModelIndex(), cols - 1, cols - 1);

   348         --cols;

   349         endRemoveColumns();

   350     }

   351 

   352     void removeAllColumns()

   353     {

   354         beginRemoveColumns(QModelIndex(), 0, cols - 1);

   355         cols = 0;

   356         endRemoveColumns();

   357     }

   358 

   359     void insertNewRow()

   360     {

   361         beginInsertRows(QModelIndex(), rows - 1, rows - 1);

   362         ++rows;

   363         endInsertRows();

   364     }

   365 

   366     void setDecorationsEnabled(bool enable)

   367     {

   368         decorationsEnabled = enable;

   369     }

   370 

   371     mutable bool fetched;

   372     bool decorationsEnabled;

   373     int rows, cols;

   374     int levels;

   375     mutable bool wrongIndex;

   376     mutable QMap<QModelIndex,QModelIndex> parentHash;

   377 };

   378 

   379 tst_QTreeView::tst_QTreeView()

   380 {

   381 }

   382 

   383 tst_QTreeView::~tst_QTreeView()

   384 {

   385 }

   386 

   387 void tst_QTreeView::initTestCase()

   388 {

   389 #ifdef Q_OS_WINCE //disable magic for WindowsCE

   390     qApp->setAutoMaximizeThreshold(-1);

   391 #endif

   392     qRegisterMetaType<QModelIndex>("QModelIndex");

   393 }

   394 

   395 void tst_QTreeView::cleanupTestCase()

   396 {

   397 }

   398 

   399 void tst_QTreeView::init()

   400 {

   401 }

   402 

   403 void tst_QTreeView::cleanup()

   404 {

   405 }

   406 

   407 // Testing get/set functions

   408 void tst_QTreeView::getSetCheck()

   409 {

   410     QTreeView obj1;

   411 

   412     // int QTreeView::indentation()

   413     // void QTreeView::setIndentation(int)

   414     QCOMPARE(obj1.indentation(), 20);

   415     obj1.setIndentation(0);

   416     QCOMPARE(obj1.indentation(), 0);

   417     obj1.setIndentation(INT_MIN);

   418     QCOMPARE(obj1.indentation(), INT_MIN);

   419     obj1.setIndentation(INT_MAX);

   420     QCOMPARE(obj1.indentation(), INT_MAX);

   421 

   422     // bool QTreeView::rootIsDecorated()

   423     // void QTreeView::setRootIsDecorated(bool)

   424     QCOMPARE(obj1.rootIsDecorated(), true);

   425     obj1.setRootIsDecorated(false);

   426     QCOMPARE(obj1.rootIsDecorated(), false);

   427     obj1.setRootIsDecorated(true);

   428     QCOMPARE(obj1.rootIsDecorated(), true);

   429 

   430     // bool QTreeView::uniformRowHeights()

   431     // void QTreeView::setUniformRowHeights(bool)

   432     QCOMPARE(obj1.uniformRowHeights(), false);

   433     obj1.setUniformRowHeights(false);

   434     QCOMPARE(obj1.uniformRowHeights(), false);

   435     obj1.setUniformRowHeights(true);

   436     QCOMPARE(obj1.uniformRowHeights(), true);

   437 

   438     // bool QTreeView::itemsExpandable()

   439     // void QTreeView::setItemsExpandable(bool)

   440     QCOMPARE(obj1.itemsExpandable(), true);

   441     obj1.setItemsExpandable(false);

   442     QCOMPARE(obj1.itemsExpandable(), false);

   443     obj1.setItemsExpandable(true);

   444     QCOMPARE(obj1.itemsExpandable(), true);

   445 

   446     // bool QTreeView::allColumnsShowFocus

   447     // void QTreeView::setAllColumnsShowFocus

   448     QCOMPARE(obj1.allColumnsShowFocus(), false);

   449     obj1.setAllColumnsShowFocus(false);

   450     QCOMPARE(obj1.allColumnsShowFocus(), false);

   451     obj1.setAllColumnsShowFocus(true);

   452     QCOMPARE(obj1.allColumnsShowFocus(), true);

   453 

   454     // bool QTreeView::isAnimated

   455     // void QTreeView::setAnimated

   456     QCOMPARE(obj1.isAnimated(), false);

   457     obj1.setAnimated(false);

   458     QCOMPARE(obj1.isAnimated(), false);

   459     obj1.setAnimated(true);

   460     QCOMPARE(obj1.isAnimated(), true);

   461 

   462     // bool QTreeView::setSortingEnabled

   463     // void QTreeView::isSortingEnabled

   464     QCOMPARE(obj1.isSortingEnabled(), false);

   465     obj1.setSortingEnabled(false);

   466     QCOMPARE(obj1.isSortingEnabled(), false);

   467     obj1.setSortingEnabled(true);

   468     QCOMPARE(obj1.isSortingEnabled(), true);

   469 }

   470 

   471 void tst_QTreeView::construction()

   472 {

   473     QTreeView view;

   474 

   475     // QAbstractItemView properties

   476     QVERIFY(!view.alternatingRowColors());

   477     QCOMPARE(view.currentIndex(), QModelIndex());

   478 #ifndef QT_NO_DRAGANDDROP

   479     QCOMPARE(view.dragDropMode(), QAbstractItemView::NoDragDrop);

   480     QVERIFY(!view.dragDropOverwriteMode());

   481     QVERIFY(!view.dragEnabled());

   482 #endif

   483     QCOMPARE(view.editTriggers(), QAbstractItemView::EditKeyPressed | QAbstractItemView::DoubleClicked);

   484     QVERIFY(view.hasAutoScroll());

   485     QCOMPARE(view.horizontalScrollMode(), QAbstractItemView::ScrollPerPixel);

   486     QCOMPARE(view.iconSize(), QSize());

   487     QCOMPARE(view.indexAt(QPoint()), QModelIndex());

   488     QVERIFY(!view.indexWidget(QModelIndex()));

   489     QVERIFY(qobject_cast<QStyledItemDelegate *>(view.itemDelegate()));

   490     QVERIFY(!view.itemDelegateForColumn(-1));

   491     QVERIFY(!view.itemDelegateForColumn(0));

   492     QVERIFY(!view.itemDelegateForColumn(1));

   493     QVERIFY(!view.itemDelegateForRow(-1));

   494     QVERIFY(!view.itemDelegateForRow(0));

   495     QVERIFY(!view.itemDelegateForRow(1));

   496     QVERIFY(!view.model());

   497     QCOMPARE(view.rootIndex(), QModelIndex());

   498     QCOMPARE(view.selectionBehavior(), QAbstractItemView::SelectRows);

   499     QCOMPARE(view.selectionMode(), QAbstractItemView::SingleSelection);

   500     QVERIFY(!view.selectionModel());

   501 #ifndef QT_NO_DRAGANDDROP

   502     QVERIFY(view.showDropIndicator());

   503 #endif

   504     QCOMPARE(view.QAbstractItemView::sizeHintForColumn(-1), -1); // <- protected in QTreeView

   505     QCOMPARE(view.QAbstractItemView::sizeHintForColumn(0), -1); // <- protected in QTreeView

   506     QCOMPARE(view.QAbstractItemView::sizeHintForColumn(1), -1); // <- protected in QTreeView

   507     QCOMPARE(view.sizeHintForIndex(QModelIndex()), QSize());

   508     QCOMPARE(view.sizeHintForRow(-1), -1);

   509     QCOMPARE(view.sizeHintForRow(0), -1);

   510     QCOMPARE(view.sizeHintForRow(1), -1);

   511     QVERIFY(!view.tabKeyNavigation());

   512     QCOMPARE(view.textElideMode(), Qt::ElideRight);

   513     QCOMPARE(view.verticalScrollMode(), QAbstractItemView::ScrollPerItem);

   514     QCOMPARE(view.visualRect(QModelIndex()), QRect());

   515 

   516     // QTreeView properties

   517     QVERIFY(!view.allColumnsShowFocus());

   518     QCOMPARE(view.autoExpandDelay(), -1);

   519     QCOMPARE(view.columnAt(-1), -1);

   520     QCOMPARE(view.columnAt(0), -1);

   521     QCOMPARE(view.columnAt(1), -1);

   522     QCOMPARE(view.columnViewportPosition(-1), -1);

   523     QCOMPARE(view.columnViewportPosition(0), -1);

   524     QCOMPARE(view.columnViewportPosition(1), -1);

   525     QCOMPARE(view.columnWidth(-1), 0);

   526     QCOMPARE(view.columnWidth(0), 0);

   527     QCOMPARE(view.columnWidth(1), 0);

   528     QVERIFY(view.header());

   529     QCOMPARE(view.indentation(), 20);

   530     QCOMPARE(view.indexAbove(QModelIndex()), QModelIndex());

   531     QCOMPARE(view.indexBelow(QModelIndex()), QModelIndex());

   532     QVERIFY(!view.isAnimated());

   533     QVERIFY(!view.isColumnHidden(-1));

   534     QVERIFY(!view.isColumnHidden(0));

   535     QVERIFY(!view.isColumnHidden(1));

   536     QVERIFY(!view.isExpanded(QModelIndex()));

   537     QVERIFY(!view.isRowHidden(-1, QModelIndex()));

   538     QVERIFY(!view.isRowHidden(0, QModelIndex()));

   539     QVERIFY(!view.isRowHidden(1, QModelIndex()));

   540     QVERIFY(!view.isFirstColumnSpanned(-1, QModelIndex()));

   541     QVERIFY(!view.isFirstColumnSpanned(0, QModelIndex()));

   542     QVERIFY(!view.isFirstColumnSpanned(1, QModelIndex()));

   543     QVERIFY(!view.isSortingEnabled());

   544     QVERIFY(view.itemsExpandable());

   545     QVERIFY(view.rootIsDecorated());

   546     QVERIFY(!view.uniformRowHeights());

   547     QCOMPARE(view.visualRect(QModelIndex()), QRect());

   548     QVERIFY(!view.wordWrap());

   549 }

   550 

   551 void tst_QTreeView::alternatingRowColors()

   552 {

   553     QTreeView view;

   554     QVERIFY(!view.alternatingRowColors());

   555     view.setAlternatingRowColors(true);

   556     QVERIFY(view.alternatingRowColors());

   557     view.setAlternatingRowColors(false);

   558     QVERIFY(!view.alternatingRowColors());

   559 

   560     // ### Test visual effect.

   561 }

   562 

   563 void tst_QTreeView::currentIndex_data()

   564 {

   565     QTest::addColumn<int>("row");

   566     QTest::addColumn<int>("column");

   567     QTest::addColumn<int>("indexRow");

   568     QTest::addColumn<int>("indexColumn");

   569     QTest::addColumn<int>("parentIndexRow");

   570     QTest::addColumn<int>("parentIndexColumn");

   571 

   572     QTest::newRow("-1, -1") << -1 << -1 << -1 << -1 << -1 << -1;

   573     QTest::newRow("-1, 0") << -1 << 0 << -1 << -1 << -1 << -1;

   574     QTest::newRow("0, -1") << 0 << -1 << -1 << -1 << -1 << -1;

   575     QTest::newRow("0, 0") << 0 << 0 << 0 << 0 << -1 << -1;

   576     QTest::newRow("0, 1") << 0 << 0 << 0 << 0 << -1 << -1;

   577     QTest::newRow("1, 0") << 1 << 0 << 1 << 0 << -1 << -1;

   578     QTest::newRow("1, 1") << 1 << 1 << -1 << -1 << -1 << -1;

   579     QTest::newRow("2, 0") << 2 << 0 << 2 << 0 << -1 << -1;

   580     QTest::newRow("2, 1") << 2 << 1 << -1 << -1 << -1 << -1;

   581     QTest::newRow("3, -1") << 3 << -1 << -1 << -1 << -1 << -1;

   582     QTest::newRow("3, 0") << 3 << 0 << -1 << -1 << -1 << -1;

   583     QTest::newRow("3, 1") << 3 << 1 << -1 << -1 << -1 << -1;

   584 }

   585 

   586 void tst_QTreeView::currentIndex()

   587 {

   588     QFETCH(int, row);

   589     QFETCH(int, column);

   590     QFETCH(int, indexRow);

   591     QFETCH(int, indexColumn);

   592     QFETCH(int, parentIndexRow);

   593     QFETCH(int, parentIndexColumn);

   594 

   595     QTreeView view;

   596     QStandardItemModel treeModel;

   597     initStandardTreeModel(&treeModel);

   598     view.setModel(&treeModel);

   599 

   600     QCOMPARE(view.currentIndex(), QModelIndex());

   601     view.setCurrentIndex(view.model()->index(row, column));

   602     QCOMPARE(view.currentIndex().row(), indexRow);

   603     QCOMPARE(view.currentIndex().column(), indexColumn);

   604     QCOMPARE(view.currentIndex().parent().row(), parentIndexRow);

   605     QCOMPARE(view.currentIndex().parent().column(), parentIndexColumn);

   606 

   607     // ### Test child and grandChild indexes.

   608 }

   609 

   610 #ifndef QT_NO_DRAGANDDROP

   611 

   612 void tst_QTreeView::dragDropMode_data()

   613 {

   614     QTest::addColumn<QAbstractItemView::DragDropMode>("dragDropMode");

   615     QTest::addColumn<bool>("acceptDrops");

   616     QTest::addColumn<bool>("dragEnabled");

   617     QTest::newRow("NoDragDrop") << QAbstractItemView::NoDragDrop << false << false;

   618     QTest::newRow("DragOnly") << QAbstractItemView::DragOnly << false << true;

   619     QTest::newRow("DropOnly") << QAbstractItemView::DropOnly << true << false;

   620     QTest::newRow("DragDrop") << QAbstractItemView::DragDrop << true << true;

   621     QTest::newRow("InternalMove") << QAbstractItemView::InternalMove << true << true;

   622 }

   623 

   624 void tst_QTreeView::dragDropMode()

   625 {

   626     QFETCH(QAbstractItemView::DragDropMode, dragDropMode);

   627     QFETCH(bool, acceptDrops);

   628     QFETCH(bool, dragEnabled);

   629 

   630     QTreeView view;

   631     QCOMPARE(view.dragDropMode(), QAbstractItemView::NoDragDrop);

   632     QVERIFY(!view.acceptDrops());

   633     QVERIFY(!view.dragEnabled());

   634 

   635     view.setDragDropMode(dragDropMode);

   636     QCOMPARE(view.dragDropMode(), dragDropMode);

   637     QCOMPARE(view.acceptDrops(), acceptDrops);

   638     QCOMPARE(view.dragEnabled(), dragEnabled);

   639 

   640     // ### Test effects of this mode

   641 }

   642 

   643 void tst_QTreeView::dragDropModeFromDragEnabledAndAcceptDrops_data()

   644 {

   645     QTest::addColumn<bool>("dragEnabled");

   646     QTest::addColumn<bool>("acceptDrops");

   647     QTest::addColumn<QAbstractItemView::DragDropMode>("dragDropMode");

   648     QTest::addColumn<QAbstractItemView::DragDropMode>("setBehavior");

   649 

   650     QTest::newRow("NoDragDrop -1") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::DragDropMode(-1);

   651     QTest::newRow("NoDragDrop 0") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::NoDragDrop;

   652     QTest::newRow("NoDragDrop 1") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::DragOnly;

   653     QTest::newRow("NoDragDrop 2") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::DropOnly;

   654     QTest::newRow("NoDragDrop 3") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::DragDrop;

   655     QTest::newRow("NoDragDrop 4") << false << false << QAbstractItemView::NoDragDrop << QAbstractItemView::InternalMove;

   656     QTest::newRow("DragOnly -1") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::DragDropMode(-1);

   657     QTest::newRow("DragOnly 0") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::NoDragDrop;

   658     QTest::newRow("DragOnly 1") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::DragOnly;

   659     QTest::newRow("DragOnly 2") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::DropOnly;

   660     QTest::newRow("DragOnly 3") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::DragDrop;

   661     QTest::newRow("DragOnly 4") << true << false << QAbstractItemView::DragOnly << QAbstractItemView::InternalMove;

   662     QTest::newRow("DropOnly -1") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::DragDropMode(-1);

   663     QTest::newRow("DropOnly 0") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::NoDragDrop;

   664     QTest::newRow("DropOnly 1") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::DragOnly;

   665     QTest::newRow("DropOnly 2") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::DropOnly;

   666     QTest::newRow("DropOnly 3") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::DragDrop;

   667     QTest::newRow("DropOnly 4") << false << true << QAbstractItemView::DropOnly << QAbstractItemView::InternalMove;

   668     QTest::newRow("DragDrop -1") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DragDropMode(-1);

   669     QTest::newRow("DragDrop 0") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DragDropMode(-1);

   670     QTest::newRow("DragDrop 1") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::NoDragDrop;

   671     QTest::newRow("DragDrop 2") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DragOnly;

   672     QTest::newRow("DragDrop 3") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DropOnly;

   673     QTest::newRow("DragDrop 4") << true << true << QAbstractItemView::DragDrop << QAbstractItemView::DragDrop;

   674     QTest::newRow("DragDrop 5") << true << true << QAbstractItemView::InternalMove << QAbstractItemView::InternalMove;

   675 }

   676 

   677 void tst_QTreeView::dragDropModeFromDragEnabledAndAcceptDrops()

   678 {

   679     QFETCH(bool, acceptDrops);

   680     QFETCH(bool, dragEnabled);

   681     QFETCH(QAbstractItemView::DragDropMode, dragDropMode);

   682     QFETCH(QAbstractItemView::DragDropMode, setBehavior);

   683 

   684     QTreeView view;

   685     QCOMPARE(view.dragDropMode(), QAbstractItemView::NoDragDrop);

   686 

   687     if (setBehavior != QAbstractItemView::DragDropMode(-1))

   688         view.setDragDropMode(setBehavior);

   689 

   690     view.setAcceptDrops(acceptDrops);

   691     view.setDragEnabled(dragEnabled);

   692     QCOMPARE(view.dragDropMode(), dragDropMode);

   693 

   694     // ### Test effects of this mode

   695 }

   696 

   697 void tst_QTreeView::dragDropOverwriteMode()

   698 {

   699     QTreeView view;

   700     QVERIFY(!view.dragDropOverwriteMode());

   701     view.setDragDropOverwriteMode(true);

   702     QVERIFY(view.dragDropOverwriteMode());

   703     view.setDragDropOverwriteMode(false);

   704     QVERIFY(!view.dragDropOverwriteMode());

   705 

   706     // ### This property changes the behavior of dropIndicatorPosition(),

   707     // which is protected and called only from within QListWidget and

   708     // QTableWidget, from their reimplementations of dropMimeData(). Hard to

   709     // test.

   710 }

   711 #endif

   712 

   713 void tst_QTreeView::editTriggers_data()

   714 {

   715     QTest::addColumn<QAbstractItemView::EditTriggers>("editTriggers");

   716     QTest::addColumn<QAbstractItemView::EditTrigger>("triggeredTrigger");

   717     QTest::addColumn<bool>("editorOpened");

   718 

   719     // NoEditTriggers

   720     QTest::newRow("NoEditTriggers 0") << QAbstractItemView::EditTriggers(QAbstractItemView::NoEditTriggers)

   721                                       << QAbstractItemView::NoEditTriggers << false;

   722     QTest::newRow("NoEditTriggers 1") << QAbstractItemView::EditTriggers(QAbstractItemView::NoEditTriggers)

   723                                       << QAbstractItemView::CurrentChanged << false;

   724     QTest::newRow("NoEditTriggers 2") << QAbstractItemView::EditTriggers(QAbstractItemView::NoEditTriggers)

   725                                       << QAbstractItemView::DoubleClicked << false;

   726     QTest::newRow("NoEditTriggers 3") << QAbstractItemView::EditTriggers(QAbstractItemView::NoEditTriggers)

   727                                       << QAbstractItemView::SelectedClicked << false;

   728     QTest::newRow("NoEditTriggers 4") << QAbstractItemView::EditTriggers(QAbstractItemView::NoEditTriggers)

   729                                       << QAbstractItemView::EditKeyPressed << false;

   730 

   731     // CurrentChanged

   732     QTest::newRow("CurrentChanged 0") << QAbstractItemView::EditTriggers(QAbstractItemView::CurrentChanged)

   733                                       << QAbstractItemView::NoEditTriggers << false;

   734     QTest::newRow("CurrentChanged 1") << QAbstractItemView::EditTriggers(QAbstractItemView::CurrentChanged)

   735                                       << QAbstractItemView::CurrentChanged << true;

   736     QTest::newRow("CurrentChanged 2") << QAbstractItemView::EditTriggers(QAbstractItemView::CurrentChanged)

   737                                       << QAbstractItemView::DoubleClicked << false;

   738     QTest::newRow("CurrentChanged 3") << QAbstractItemView::EditTriggers(QAbstractItemView::CurrentChanged)

   739                                       << QAbstractItemView::SelectedClicked << false;

   740     QTest::newRow("CurrentChanged 4") << QAbstractItemView::EditTriggers(QAbstractItemView::CurrentChanged)

   741                                       << QAbstractItemView::EditKeyPressed << false;

   742 

   743     // DoubleClicked

   744     QTest::newRow("DoubleClicked 0") << QAbstractItemView::EditTriggers(QAbstractItemView::DoubleClicked)

   745                                      << QAbstractItemView::NoEditTriggers << false;

   746     QTest::newRow("DoubleClicked 1") << QAbstractItemView::EditTriggers(QAbstractItemView::DoubleClicked)

   747                                      << QAbstractItemView::CurrentChanged << false;

   748     QTest::newRow("DoubleClicked 2") << QAbstractItemView::EditTriggers(QAbstractItemView::DoubleClicked)

   749                                      << QAbstractItemView::DoubleClicked << true;

   750     QTest::newRow("DoubleClicked 3") << QAbstractItemView::EditTriggers(QAbstractItemView::DoubleClicked)

   751                                      << QAbstractItemView::SelectedClicked << false;

   752     QTest::newRow("DoubleClicked 4") << QAbstractItemView::EditTriggers(QAbstractItemView::DoubleClicked)

   753                                      << QAbstractItemView::EditKeyPressed << false;

   754 

   755     // SelectedClicked

   756     QTest::newRow("SelectedClicked 0") << QAbstractItemView::EditTriggers(QAbstractItemView::SelectedClicked)

   757                                        << QAbstractItemView::NoEditTriggers << false;

   758     QTest::newRow("SelectedClicked 1") << QAbstractItemView::EditTriggers(QAbstractItemView::SelectedClicked)

   759                                        << QAbstractItemView::CurrentChanged << false;

   760     QTest::newRow("SelectedClicked 2") << QAbstractItemView::EditTriggers(QAbstractItemView::SelectedClicked)

   761                                        << QAbstractItemView::DoubleClicked << false;

   762     QTest::newRow("SelectedClicked 3") << QAbstractItemView::EditTriggers(QAbstractItemView::SelectedClicked)

   763                                        << QAbstractItemView::SelectedClicked << true;

   764     QTest::newRow("SelectedClicked 4") << QAbstractItemView::EditTriggers(QAbstractItemView::SelectedClicked)

   765                                        << QAbstractItemView::EditKeyPressed << false;

   766 

   767     // EditKeyPressed

   768     QTest::newRow("EditKeyPressed 0") << QAbstractItemView::EditTriggers(QAbstractItemView::EditKeyPressed)

   769                                       << QAbstractItemView::NoEditTriggers << false;

   770     QTest::newRow("EditKeyPressed 1") << QAbstractItemView::EditTriggers(QAbstractItemView::EditKeyPressed)

   771                                       << QAbstractItemView::CurrentChanged << false;

   772     QTest::newRow("EditKeyPressed 2") << QAbstractItemView::EditTriggers(QAbstractItemView::EditKeyPressed)

   773                                       << QAbstractItemView::DoubleClicked << false;

   774     QTest::newRow("EditKeyPressed 3") << QAbstractItemView::EditTriggers(QAbstractItemView::EditKeyPressed)

   775                                       << QAbstractItemView::SelectedClicked << false;

   776     QTest::newRow("EditKeyPressed 4") << QAbstractItemView::EditTriggers(QAbstractItemView::EditKeyPressed)

   777                                       << QAbstractItemView::EditKeyPressed << true;

   778 }

   779 

   780 void tst_QTreeView::editTriggers()

   781 {

   782     QFETCH(QAbstractItemView::EditTriggers, editTriggers);

   783     QFETCH(QAbstractItemView::EditTrigger, triggeredTrigger);

   784     QFETCH(bool, editorOpened);

   785 

   786     QTreeView view;

   787     QStandardItemModel treeModel;

   788     initStandardTreeModel(&treeModel);

   789     view.setModel(&treeModel);

   790     view.show();

   791 

   792     QCOMPARE(view.editTriggers(), QAbstractItemView::EditKeyPressed | QAbstractItemView::DoubleClicked);

   793 

   794     // Initialize the first index

   795     view.setCurrentIndex(view.model()->index(0, 0));

   796 

   797     // Verify that we don't have any editor initially

   798     QVERIFY(!qFindChild<QLineEdit *>(&view, QString()));

   799 

   800     // Set the triggers

   801     view.setEditTriggers(editTriggers);

   802 

   803     // Interact with the view

   804     switch (triggeredTrigger) {

   805     case QAbstractItemView::NoEditTriggers:

   806         // Do nothing, the editor shouldn't be there

   807         break;

   808     case QAbstractItemView::CurrentChanged:

   809         // Change the index to open an editor

   810         view.setCurrentIndex(view.model()->index(1, 0));

   811         break;

   812     case QAbstractItemView::DoubleClicked:

   813         // Doubleclick the center of the current cell

   814         QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,

   815                           view.visualRect(view.model()->index(0, 0)).center());

   816         QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0,

   817                            view.visualRect(view.model()->index(0, 0)).center());

   818         break;

   819     case QAbstractItemView::SelectedClicked:

   820         // Click the center of the current cell

   821         view.selectionModel()->select(view.model()->index(0, 0), QItemSelectionModel::Select);

   822         QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,

   823                           view.visualRect(view.model()->index(0, 0)).center());

   824         QTest::qWait(int(QApplication::doubleClickInterval() * 1.5));

   825         break;

   826     case QAbstractItemView::EditKeyPressed:

   827         view.setFocus();

   828 #ifdef Q_OS_MAC

   829         // Mac OS X uses Enter for editing

   830         QTest::keyPress(&view, Qt::Key_Enter);

   831 #else

   832         // All other platforms use F2

   833         QTest::keyPress(&view, Qt::Key_F2);

   834 #endif

   835         break;

   836     default:

   837         break;

   838     }

   839 

   840     // Check if we got an editor

   841     QTRY_COMPARE(qFindChild<QLineEdit *>(&view, QString()) != 0, editorOpened);

   842 }

   843 

   844 void tst_QTreeView::hasAutoScroll()

   845 {

   846     QTreeView view;

   847     QVERIFY(view.hasAutoScroll());

   848     view.setAutoScroll(false);

   849     QVERIFY(!view.hasAutoScroll());

   850     view.setAutoScroll(true);

   851     QVERIFY(view.hasAutoScroll());

   852 }

   853 

   854 void tst_QTreeView::horizontalScrollMode()

   855 {

   856     QStandardItemModel model;

   857     for (int i = 0; i < 100; ++i) {

   858         model.appendRow(QList<QStandardItem *>()

   859                         << new QStandardItem("An item that has very long text and should"

   860                                              " cause the horizontal scroll bar to appear.")

   861                         << new QStandardItem("An item that has very long text and should"

   862                                              " cause the horizontal scroll bar to appear."));

   863     }

   864 

   865     QTreeView view;

   866     view.setModel(&model);

   867     view.setFixedSize(100, 100);

   868     view.header()->resizeSection(0, 200);

   869     view.show();

   870 

   871     QCOMPARE(view.horizontalScrollMode(), QAbstractItemView::ScrollPerPixel);

   872     QCOMPARE(view.horizontalScrollBar()->minimum(), 0);

   873     QVERIFY(view.horizontalScrollBar()->maximum() > 2);

   874 

   875     view.setHorizontalScrollMode(QAbstractItemView::ScrollPerItem);

   876     QCOMPARE(view.horizontalScrollMode(), QAbstractItemView::ScrollPerItem);

   877     QCOMPARE(view.horizontalScrollBar()->minimum(), 0);

   878     QCOMPARE(view.horizontalScrollBar()->maximum(), 1);

   879 

   880     view.setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);

   881     QCOMPARE(view.horizontalScrollMode(), QAbstractItemView::ScrollPerPixel);

   882     QCOMPARE(view.horizontalScrollBar()->minimum(), 0);

   883     QVERIFY(view.horizontalScrollBar()->maximum() > 2);

   884 }

   885 

   886 class RepaintTreeView : public QTreeView

   887 {

   888 public:

   889     RepaintTreeView() : repainted(false) { }

   890     bool repainted;

   891 

   892 protected:

   893     void paintEvent(QPaintEvent *event)

   894     { repainted = true; QTreeView::paintEvent(event); }

   895 };

   896 

   897 void tst_QTreeView::iconSize()

   898 {

   899     RepaintTreeView view;

   900     QCOMPARE(view.iconSize(), QSize());

   901 

   902     QStandardItemModel treeModel;

   903     initStandardTreeModel(&treeModel);

   904     view.setModel(&treeModel);

   905     QCOMPARE(view.iconSize(), QSize());

   906     QVERIFY(!view.repainted);

   907 

   908     view.show();

   909     view.update();

   910     QTest::qWaitForWindowShown(&view);

   911     QTRY_VERIFY(view.repainted);

   912     QCOMPARE(view.iconSize(), QSize());

   913 

   914     view.repainted = false;

   915     view.setIconSize(QSize());

   916     QTRY_VERIFY(!view.repainted);

   917     QCOMPARE(view.iconSize(), QSize());

   918 

   919     view.setIconSize(QSize(10, 10));

   920     QTRY_VERIFY(view.repainted);

   921     QCOMPARE(view.iconSize(), QSize(10, 10));

   922 

   923     view.repainted = false;

   924     view.setIconSize(QSize(10000, 10000));

   925     QTRY_VERIFY(view.repainted);

   926     QCOMPARE(view.iconSize(), QSize(10000, 10000));

   927 }

   928 

   929 void tst_QTreeView::indexAt()

   930 {

   931     QtTestModel model;

   932     model.rows = model.cols = 5;

   933 

   934     QTreeView view;

   935     QCOMPARE(view.indexAt(QPoint()), QModelIndex());

   936     view.setModel(&model);

   937     QVERIFY(view.indexAt(QPoint()) != QModelIndex());

   938 

   939     QSize itemSize = view.visualRect(model.index(0, 0)).size();

   940     for (int i = 0; i < model.rowCount(); ++i) {

   941         QPoint pos(itemSize.width() / 2, (i * itemSize.height()) + (itemSize.height() / 2));

   942         QModelIndex index = view.indexAt(pos);

   943         QCOMPARE(index, model.index(i, 0));

   944     }

   945 

   946     /*

   947       // ### this is wrong; the widget _will_ affect the item size

   948     for (int j = 0; j < model.rowCount(); ++j)

   949         view.setIndexWidget(model.index(j, 0), new QPushButton);

   950     */

   951 

   952     for (int k = 0; k < model.rowCount(); ++k) {

   953         QPoint pos(itemSize.width() / 2, (k * itemSize.height()) + (itemSize.height() / 2));

   954         QModelIndex index = view.indexAt(pos);

   955         QCOMPARE(index, model.index(k, 0));

   956     }

   957 

   958     view.show();

   959     view.resize(600, 600);

   960     view.header()->setStretchLastSection(false);

   961     QCOMPARE(view.indexAt(QPoint(550, 20)), QModelIndex());

   962 }

   963 

   964 void tst_QTreeView::indexWidget()

   965 {

   966     QTreeView view;

   967     QStandardItemModel treeModel;

   968     initStandardTreeModel(&treeModel);

   969     view.setModel(&treeModel);

   970 

   971     QModelIndex index = view.model()->index(0, 0);

   972 

   973     QVERIFY(!view.indexWidget(QModelIndex()));

   974     QVERIFY(!view.indexWidget(index));

   975 

   976     QString text = QLatin1String("TestLabel");

   977 

   978     QWidget *label = new QLabel(text);

   979     view.setIndexWidget(QModelIndex(), label);

   980     QVERIFY(!view.indexWidget(QModelIndex()));

   981     QVERIFY(!label->parent());

   982     view.setIndexWidget(index, label);

   983     QCOMPARE(view.indexWidget(index), label);

   984     QCOMPARE(label->parentWidget(), view.viewport());

   985 

   986 

   987     QTextEdit *widget = new QTextEdit(text);

   988     widget->setFixedSize(200,100);

   989     view.setIndexWidget(index, widget);

   990     QCOMPARE(view.indexWidget(index), static_cast<QWidget *>(widget));

   991 

   992     QCOMPARE(widget->parentWidget(), view.viewport());

   993     QCOMPARE(widget->geometry(), view.visualRect(index).intersected(widget->geometry()));

   994     QCOMPARE(widget->toPlainText(), text);

   995 

   996     //now let's try to do that later when the widget is already shown

   997     view.show();

   998     index = view.model()->index(1, 0);

   999     QVERIFY(!view.indexWidget(index));

  1000 

  1001     widget = new QTextEdit(text);

  1002     widget->setFixedSize(200,100);

  1003     view.setIndexWidget(index, widget);

  1004     QCOMPARE(view.indexWidget(index), static_cast<QWidget *>(widget));

  1005 

  1006     QCOMPARE(widget->parentWidget(), view.viewport());

  1007     QCOMPARE(widget->geometry(), view.visualRect(index).intersect(widget->geometry()));

  1008     QCOMPARE(widget->toPlainText(), text);

  1009 }

  1010 

  1011 void tst_QTreeView::itemDelegate()

  1012 {

  1013     QPointer<QAbstractItemDelegate> oldDelegate;

  1014     QPointer<QItemDelegate> otherItemDelegate;

  1015 

  1016     {

  1017         QTreeView view;

  1018         QVERIFY(qobject_cast<QStyledItemDelegate *>(view.itemDelegate()));

  1019         QPointer<QAbstractItemDelegate> oldDelegate = view.itemDelegate();

  1020 

  1021         otherItemDelegate = new QItemDelegate;

  1022         view.setItemDelegate(otherItemDelegate);

  1023         QVERIFY(!otherItemDelegate->parent());

  1024         QVERIFY(oldDelegate);

  1025 

  1026         QCOMPARE(view.itemDelegate(), (QAbstractItemDelegate *)otherItemDelegate);

  1027 

  1028         view.setItemDelegate(0);

  1029         QVERIFY(!view.itemDelegate()); // <- view does its own drawing?

  1030         QVERIFY(otherItemDelegate);

  1031     }

  1032 

  1033     // This is strange. Why doesn't setItemDelegate() reparent the delegate?

  1034     QVERIFY(!oldDelegate);

  1035     QVERIFY(otherItemDelegate);

  1036 

  1037     delete otherItemDelegate;

  1038 }

  1039 

  1040 void tst_QTreeView::itemDelegateForColumnOrRow()

  1041 {

  1042     QTreeView view;

  1043     QAbstractItemDelegate *defaultDelegate = view.itemDelegate();

  1044     QVERIFY(defaultDelegate);

  1045 

  1046     QVERIFY(!view.itemDelegateForRow(0));

  1047     QVERIFY(!view.itemDelegateForColumn(0));

  1048     QCOMPARE(view.itemDelegate(QModelIndex()), defaultDelegate);

  1049 

  1050     QStandardItemModel model;

  1051     for (int i = 0; i < 100; ++i) {

  1052         model.appendRow(QList<QStandardItem *>()

  1053                         << new QStandardItem("An item that has very long text and should"

  1054                                              " cause the horizontal scroll bar to appear.")

  1055                         << new QStandardItem("An item that has very long text and should"

  1056                                              " cause the horizontal scroll bar to appear.")

  1057                         << new QStandardItem("An item that has very long text and should"

  1058                                              " cause the horizontal scroll bar to appear."));

  1059     }

  1060     view.setModel(&model);

  1061 

  1062     QVERIFY(!view.itemDelegateForRow(0));

  1063     QVERIFY(!view.itemDelegateForColumn(0));

  1064     QCOMPARE(view.itemDelegate(QModelIndex()), defaultDelegate);

  1065     QCOMPARE(view.itemDelegate(view.model()->index(0, 0)), defaultDelegate);

  1066 

  1067     QPointer<QAbstractItemDelegate> rowDelegate = new QItemDelegate;

  1068     view.setItemDelegateForRow(0, rowDelegate);

  1069     QVERIFY(!rowDelegate->parent());

  1070     QCOMPARE(view.itemDelegateForRow(0), (QAbstractItemDelegate *)rowDelegate);

  1071     QCOMPARE(view.itemDelegate(view.model()->index(0, 0)), (QAbstractItemDelegate *)rowDelegate);

  1072     QCOMPARE(view.itemDelegate(view.model()->index(0, 1)), (QAbstractItemDelegate *)rowDelegate);

  1073     QCOMPARE(view.itemDelegate(view.model()->index(1, 0)), defaultDelegate);

  1074     QCOMPARE(view.itemDelegate(view.model()->index(1, 1)), defaultDelegate);

  1075 

  1076     QPointer<QAbstractItemDelegate> columnDelegate = new QItemDelegate;

  1077     view.setItemDelegateForColumn(1, columnDelegate);

  1078     QVERIFY(!columnDelegate->parent());

  1079     QCOMPARE(view.itemDelegateForColumn(1), (QAbstractItemDelegate *)columnDelegate);

  1080     QCOMPARE(view.itemDelegate(view.model()->index(0, 0)), (QAbstractItemDelegate *)rowDelegate);

  1081     QCOMPARE(view.itemDelegate(view.model()->index(0, 1)), (QAbstractItemDelegate *)rowDelegate); // row wins

  1082     QCOMPARE(view.itemDelegate(view.model()->index(1, 0)), defaultDelegate);

  1083     QCOMPARE(view.itemDelegate(view.model()->index(1, 1)), (QAbstractItemDelegate *)columnDelegate);

  1084 

  1085     view.setItemDelegateForRow(0, 0);

  1086     QVERIFY(!view.itemDelegateForRow(0));

  1087     QVERIFY(rowDelegate); // <- wasn't deleted

  1088 

  1089     view.setItemDelegateForColumn(1, 0);

  1090     QVERIFY(!view.itemDelegateForColumn(1));

  1091     QVERIFY(columnDelegate); // <- wasn't deleted

  1092 

  1093     delete rowDelegate;

  1094     delete columnDelegate;

  1095 }

  1096 

  1097 void tst_QTreeView::keyboardSearch()

  1098 {

  1099     QTreeView view;

  1100     QStandardItemModel model;

  1101     model.appendRow(new QStandardItem("Andreas"));

  1102     model.appendRow(new QStandardItem("Baldrian"));

  1103     model.appendRow(new QStandardItem("Cecilie"));

  1104     view.setModel(&model);

  1105     view.show();

  1106 

  1107     // Nothing is selected

  1108     QVERIFY(!view.selectionModel()->hasSelection());

  1109     QVERIFY(!view.selectionModel()->isSelected(model.index(0, 0)));

  1110 

  1111     // First item is selected

  1112     view.keyboardSearch(QLatin1String("A"));

  1113     QTRY_VERIFY(view.selectionModel()->isSelected(model.index(0, 0)));

  1114 

  1115     // First item is still selected

  1116     view.keyboardSearch(QLatin1String("n"));

  1117     QVERIFY(view.selectionModel()->isSelected(model.index(0, 0)));

  1118 

  1119     // No "AnB" item - keep the same selection.

  1120     view.keyboardSearch(QLatin1String("B"));

  1121     QVERIFY(view.selectionModel()->isSelected(model.index(0, 0)));

  1122 

  1123     // Wait a bit.

  1124     QTest::qWait(QApplication::keyboardInputInterval() * 2);

  1125 

  1126     // The item that starts with B is selected.

  1127     view.keyboardSearch(QLatin1String("B"));

  1128     QVERIFY(view.selectionModel()->isSelected(model.index(1, 0)));

  1129 }

  1130 

  1131 void tst_QTreeView::setModel()

  1132 {

  1133     QTreeView view;

  1134     view.show();