1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: Container for pan (drag) gesture -related data and logic.

    15 *

    16 */

    17 

    18 #include <QtTest/QtTest>

    19 #include <QMetaType>

    20 #include <QModelIndex>

    21 #include "hbautotest.h"

    22 #include <hbapplication.h>

    23 #include <hbmainwindow.h>

    24 #include <hbscrollbar>

    25 #include <hgwidgets/hgwidgets.h>

    26 #include <hgwidgets/hggrid.h>

    27 #include <hgwidgets/hgmediawall.h>

    28 

    29 Q_DECLARE_METATYPE(QItemSelection)

    30 Q_DECLARE_METATYPE(QModelIndex)

    31 

    32 static const QPointF grid_portrait_pos0(70, 30);

    33 static const QPointF grid_portrait_pos1(180, 30);

    34 static const QPointF grid_portrait_pos2(280, 30);

    35 static const QPointF grid_portrait_pos3(70, 120);

    36 static const QPointF grid_portrait_pos4(180, 120);

    37 static const QPointF grid_portrait_pos5(280, 120);

    38 static const QPointF grid_portrait_pos6(70, 200);

    39 static const QPointF grid_portrait_pos7(180, 200);

    40 static const QPointF grid_portrait_pos8(280, 200);

    41 

    42 class TestGanesWidgets : public QObject

    43 {

    44     Q_OBJECT

    45 

    46 public:

    47 

    48     TestGanesWidgets();

    49     virtual ~TestGanesWidgets();

    50 

    51 private slots:

    52     void initTestCase();

    53     void cleanupTestCase();

    54     void init();

    55     void cleanup();

    56 

    57 private slots:

    58     void test_panGridLandscape();

    59     void test_panGridPortrait();

    60     void test_panCoverFlowLandscape();

    61     void test_panCoverFlowPortrait();

    62     void test_scrollbarGridLandscape();

    63     void test_scrollbarGridPortrait();

    64     void test_scrollbarCoverFlowLandscape();

    65     void test_scrollbarCoverFlowPortrait();

    66     void test_addRemoveItemsGrid();

    67     void test_addRemoveItemsCoverflow();

    68     void test_updateData();

    69     void test_tap();

    70     void test_currentItemCoverflow();

    71     void test_currentItemGrid();

    72     void test_selectionMode();

    73     void test_selectionModel();

    74     void test_scrollTo();

    75     void test_addItemsCoverFlow();

    76     void test_removeItemsCoverFlow();

    77     void test_moveItemsCoverFlow();

    78 

    79 private:

    80 

    81     void pan( Qt::Orientation, TBool begin );

    82 

    83 private:

    84 

    85     HbMainWindow* mWindow;

    86     HgWidget* mWidget;

    87 

    88 };

    89 

    90 class TestModel : public QAbstractListModel

    91 {

    92     Q_OBJECT

    93 

    94 public:

    95 

    96     explicit TestModel(QList<QModelIndex> *requestedIndexes = 0);

    97     virtual ~TestModel();

    98 

    99     int rowCount(const QModelIndex &parent=QModelIndex()) const;

   100     QVariant data(const QModelIndex &index, int role=Qt::DisplayRole) const;

   101 

   102     void generateItems(int count);

   103     void appendItem();

   104     void insertItems(int index, int count=1);

   105     void removeItems(int index, int count=1);

   106     void moveItems(int from, int to, int count=1);

   107     void changeItem(int index);

   108     void reset();

   109 

   110     QImage mImage;

   111     QStringList mItems;

   112     bool mValidData;

   113 

   114     QList<QModelIndex> *mRequestedIndexes;

   115 };

   116 

   117 TestModel::TestModel(QList<QModelIndex> *requestedIndexes) :

   118     mValidData(true),

   119     mRequestedIndexes(requestedIndexes)

   120 {

   121     mImage = QImage(":icons/startupHG.jpg");

   122 }

   123 

   124 TestModel::~TestModel()

   125 {

   126 

   127 }

   128 

   129 void TestModel::generateItems(int count)

   130 {

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

   132         mItems.append(QString("Item %0").arg(i));

   133     }

   134 }

   135 

   136 void TestModel::appendItem()

   137 {

   138     insertItems(mItems.count(),1);

   139 }

   140 

   141 void TestModel::insertItems(int index, int count)

   142 {

   143     beginInsertRows(QModelIndex(), index, index+count-1); // Inclusive

   144     int end = index+count;

   145     for ( ;index<end; index++) {

   146         mItems.insert(index, QString("Item %0").arg(mItems.count()));

   147     }

   148     endInsertRows();

   149 }

   150 

   151 void TestModel::removeItems(int index, int count)

   152 {

   153     if (index >= 0 && index < mItems.count()) {

   154         beginRemoveRows(QModelIndex(), index, index+count-1); // Inclusive

   155         int end = index+count;

   156         for (; index<end; index++) {

   157             mItems.removeAt(index);

   158         }

   159         endRemoveRows();

   160     }

   161 }

   162 

   163 void TestModel::moveItems(int from, int to, int count)

   164 {

   165     if (beginMoveRows(QModelIndex(), from, from+count-1, QModelIndex(), to)) { // Inclusive

   166         // No need to actually move rows here

   167         endMoveRows();

   168     }

   169     else {

   170         qDebug() << "Cannot move" << from << "-" << from+count-1 << "to" << to;

   171     }

   172 }

   173 

   174 void TestModel::reset()

   175 {

   176     beginResetModel();

   177     mItems.clear();

   178     endResetModel();

   179 }

   180 

   181 

   182 void TestModel::changeItem(int index)

   183 {

   184     if ( index >= 0 && index < mItems.count() ) {

   185         QModelIndex modelIndex = QAbstractItemModel::createIndex(index, 0);

   186         emit dataChanged(modelIndex, modelIndex);

   187     }

   188 }

   189 

   190 int TestModel::rowCount(const QModelIndex &parent) const

   191 {

   192     return mItems.count();

   193 }

   194 

   195 QVariant TestModel::data(const QModelIndex &index, int role) const

   196 {

   197     QVariant returnValue;

   198 

   199     if( !mValidData)

   200         return returnValue;

   201 

   202     int row = index.row();

   203 

   204     switch ( role )

   205         {

   206         case Qt::DisplayRole:

   207             {

   208             QStringList texts;

   209             QString text("Primary %0");

   210             text.arg(row);

   211             texts << text;

   212             text = "Secondary %0";

   213             text.arg(row);

   214             texts << text;

   215             returnValue = texts;

   216             break;

   217             }

   218         case Qt::DecorationRole:

   219             {

   220             returnValue = mImage;

   221             if (mRequestedIndexes && !mRequestedIndexes->contains(index)) {

   222                 mRequestedIndexes->append(index);

   223                 qSort(*mRequestedIndexes);

   224             }

   225             break;

   226             }

   227         default:

   228             break;

   229 

   230         }

   231 

   232     return returnValue;

   233 }

   234 

   235 

   236 TestGanesWidgets::TestGanesWidgets()

   237 {

   238 }

   239 

   240 TestGanesWidgets::~TestGanesWidgets()

   241 {

   242 

   243 }

   244 

   245 void TestGanesWidgets::initTestCase()

   246 {

   247 

   248 }

   249 

   250 void TestGanesWidgets::cleanupTestCase()

   251 {

   252 

   253 }

   254 

   255 void TestGanesWidgets::init()

   256 {

   257 

   258 }

   259 

   260 void TestGanesWidgets::cleanup()

   261 {

   262 

   263 }

   264 

   265 void TestGanesWidgets::pan( Qt::Orientation orientation, TBool begin )

   266 {

   267     QPointF start(100,100);

   268     QPointF move;

   269     QPointF end;

   270     if (orientation==Qt::Horizontal){

   271         move = QPointF(100,0);

   272     }

   273     else {

   274         move = QPointF(0,100);

   275     }

   276 

   277     if( begin )

   278         end = start - move;

   279     else

   280         end = start + move;

   281 

   282     HbAutoTest::mousePress( (HbAutoTestMainWindow*)mWindow, mWidget, start, -1 );

   283     HbAutoTest::mouseMove( (HbAutoTestMainWindow*)mWindow, mWidget, end, -1 );

   284     HbAutoTest::mouseRelease( (HbAutoTestMainWindow*)mWindow, mWidget, end, 100 );

   285 }

   286 

   287 void TestGanesWidgets::test_panGridLandscape()

   288 {

   289     mWindow = new HbMainWindow;

   290     mWidget = new HgGrid(Qt::Horizontal);

   291     TestModel model;

   292     model.generateItems(30);

   293     mWindow->addView( mWidget );

   294     QVERIFY( mWidget->model() == 0 );

   295     mWidget->setModel( &model );

   296     QVERIFY( &model == mWidget->model() );

   297 

   298     mWindow->show();

   299 

   300     QTest::qWait( 2000 );

   301 

   302     pan( Qt::Horizontal, true );

   303 

   304     model.reset();

   305     model.generateItems(5);

   306 

   307     QTest::qWait( 2000 );

   308 

   309     pan( Qt::Horizontal, false );

   310 

   311     model.reset();

   312 

   313     QTest::qWait( 2000 );

   314 

   315     pan( Qt::Horizontal, true );

   316 

   317     QTest::qWait(4000);

   318 

   319     delete mWindow;

   320     mWindow = 0;

   321 }

   322 

   323 void TestGanesWidgets::test_panGridPortrait()

   324 {

   325     mWindow = new HbMainWindow;

   326     mWidget = new HgGrid(Qt::Vertical );

   327     TestModel model;

   328     model.generateItems(30);

   329     mWindow->addView( mWidget );

   330     QVERIFY( mWidget->model() == 0 );

   331     mWidget->setModel( &model );

   332     QVERIFY( &model == mWidget->model() );

   333     mWindow->show();

   334 

   335     QTest::qWait( 2000 );

   336 

   337     pan( Qt::Vertical, true );

   338 

   339     model.reset();

   340     model.generateItems(5);

   341 

   342     QTest::qWait( 2000 );

   343 

   344     pan( Qt::Vertical, false );

   345 

   346     model.reset();

   347 

   348     QTest::qWait( 2000 );

   349 

   350     pan( Qt::Vertical, true );

   351 

   352     QTest::qWait(4000);

   353 

   354     delete mWindow;

   355     mWindow = 0;

   356 }

   357 

   358 void TestGanesWidgets::test_panCoverFlowLandscape()

   359 {

   360     mWindow = new HbMainWindow;

   361     mWidget = new HgMediawall();

   362     TestModel model;

   363     model.generateItems(30);

   364     mWindow->addView( mWidget );

   365     QVERIFY( mWidget->model() == 0 );

   366     mWidget->setModel( &model );

   367     QVERIFY( &model == mWidget->model() );

   368     mWindow->show();

   369 

   370     QTest::qWait( 2000 );

   371 

   372     pan( Qt::Horizontal, true );

   373 

   374     model.reset();

   375     model.generateItems(5);

   376 

   377     QTest::qWait( 2000 );

   378 

   379     pan( Qt::Horizontal, false );

   380 

   381     model.reset();

   382 

   383     QTest::qWait( 2000 );

   384 

   385     pan( Qt::Horizontal, true );

   386 

   387     QTest::qWait(4000);

   388 

   389     delete mWindow;

   390     mWindow = 0;

   391 }

   392 

   393 void TestGanesWidgets::test_panCoverFlowPortrait()

   394 {

   395     mWindow = new HbMainWindow;

   396     mWidget = new HgMediawall();

   397     TestModel model;

   398     model.generateItems(30);

   399     mWindow->addView( mWidget );

   400     QVERIFY( mWidget->model() == 0 );

   401     mWidget->setModel( &model );

   402     QVERIFY( &model == mWidget->model() );

   403     mWindow->show();

   404 

   405     QTest::qWait( 2000 );

   406 

   407     pan( Qt::Vertical, true );

   408 

   409     model.reset();

   410     model.generateItems(5);

   411 

   412     QTest::qWait( 2000 );

   413 

   414     pan( Qt::Vertical, false );

   415 

   416     model.reset();

   417 

   418     QTest::qWait( 2000 );

   419 

   420     pan( Qt::Vertical, true );

   421 

   422     QTest::qWait(4000);

   423 

   424     delete mWindow;

   425     mWindow = 0;

   426 }

   427 

   428 void TestGanesWidgets::test_scrollbarGridLandscape()

   429 {

   430     mWindow = new HbMainWindow;

   431     mWidget = new HgMediawall();

   432     TestModel model;

   433     model.generateItems(200);

   434     mWindow->addView( mWidget );

   435     mWidget->setModel( &model );

   436     mWindow->show();

   437 

   438     QTest::qWait( 2000 );

   439 

   440     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAutoHide);

   441 

   442     mWidget->setScrollBarPolicy(HgWidget::ScrollBarAlwaysOn);

   443     mWidget->scrollBar()->setInteractive(true);

   444     QRectF rect = mWidget->scrollBar()->rect();

   445 

   446     QTest::qWait(1000);

   447 

   448     QPointF move( 20,0 );

   449 

   450     HbAutoTest::mousePress( (HbAutoTestMainWindow*)mWindow, mWidget->scrollBar(), rect.topLeft()+move, -1 );

   451     HbAutoTest::mouseMove( (HbAutoTestMainWindow*)mWindow, mWidget->scrollBar(), rect.topRight()-move, 50 );

   452     HbAutoTest::mouseRelease( (HbAutoTestMainWindow*)mWindow, mWidget->scrollBar(), rect.topRight()-move, 100 );

   453 

   454     QTest::qWait(3000);

   455 

   456     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAlwaysOn );

   457     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAlwaysOn);

   458     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAlwaysOff );

   459     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAlwaysOff);

   460     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAutoHide );

   461     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAutoHide);

   462 

   463     QVERIFY(mWidget->scrollBar() != 0);

   464     HbScrollBar* scrollBar = new HbScrollBar();

   465     mWidget->setScrollBar(scrollBar);

   466     QVERIFY(mWidget->scrollBar()==scrollBar);

   467     mWidget->setScrollBar(0);

   468     QVERIFY(mWidget->scrollBar()!= 0);

   469 

   470     QTest::qWait(2000);

   471 

   472     delete mWindow;

   473     mWindow = 0;

   474 

   475 }

   476 

   477 void TestGanesWidgets::test_scrollbarGridPortrait()

   478 {

   479     mWindow = new HbMainWindow;

   480     mWidget = new HgMediawall();

   481     TestModel model;

   482     model.generateItems(200);

   483     mWindow->addView( mWidget );

   484     mWidget->setModel( &model );

   485     mWindow->show();

   486 

   487     QTest::qWait( 2000 );

   488 

   489     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAutoHide);

   490     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAlwaysOn );

   491     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAlwaysOn);

   492     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAlwaysOff );

   493     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAlwaysOff);

   494     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAutoHide );

   495     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAutoHide);

   496 

   497     QVERIFY(mWidget->scrollBar() != 0);

   498     HbScrollBar* scrollBar = new HbScrollBar();

   499     mWidget->setScrollBar(scrollBar);

   500     QVERIFY(mWidget->scrollBar()==scrollBar);

   501     mWidget->setScrollBar(0);

   502     QVERIFY(mWidget->scrollBar()!= 0);

   503 

   504     QTest::qWait(2000);

   505 

   506     delete mWindow;

   507     mWindow = 0;

   508 

   509 }

   510 

   511 void TestGanesWidgets::test_scrollbarCoverFlowLandscape()

   512 {

   513     mWindow = new HbMainWindow;

   514     mWidget = new HgMediawall();

   515     TestModel model;

   516     model.generateItems(200);

   517     mWindow->addView( mWidget );

   518     mWidget->setModel( &model );

   519     mWindow->show();

   520 

   521     QTest::qWait( 2000 );

   522 

   523     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAutoHide);

   524     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAlwaysOn );

   525     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAlwaysOn);

   526     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAlwaysOff );

   527     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAlwaysOff);

   528     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAutoHide );

   529     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAutoHide);

   530 

   531     QVERIFY(mWidget->scrollBar() != 0);

   532     HbScrollBar* scrollBar = new HbScrollBar();

   533     mWidget->setScrollBar(scrollBar);

   534     QVERIFY(mWidget->scrollBar()==scrollBar);

   535     mWidget->setScrollBar(0);

   536     QVERIFY(mWidget->scrollBar()!= 0);

   537 

   538     QTest::qWait(2000);

   539 

   540     delete mWindow;

   541     mWindow = 0;

   542 

   543 }

   544 

   545 void TestGanesWidgets::test_scrollbarCoverFlowPortrait()

   546 {

   547     mWindow = new HbMainWindow;

   548     mWidget = new HgMediawall();

   549     TestModel model;

   550     model.generateItems(200);

   551     mWindow->addView( mWidget );

   552     mWidget->setModel( &model );

   553     mWindow->show();

   554 

   555     QTest::qWait( 2000 );

   556 

   557     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAutoHide);

   558     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAlwaysOn );

   559     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAlwaysOn);

   560     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAlwaysOff );

   561     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAlwaysOff);

   562     mWidget->setScrollBarPolicy( HgWidget::ScrollBarAutoHide );

   563     QVERIFY(mWidget->scrollBarPolicy() == HgWidget::ScrollBarAutoHide);

   564 

   565     QVERIFY(mWidget->scrollBar() != 0);

   566     HbScrollBar* scrollBar = new HbScrollBar();

   567     mWidget->setScrollBar(scrollBar);

   568     QVERIFY(mWidget->scrollBar()==scrollBar);

   569     mWidget->setScrollBar(0);

   570     QVERIFY(mWidget->scrollBar()!= 0);

   571 

   572     QTest::qWait(2000);

   573 

   574     delete mWindow;

   575     mWindow = 0;

   576 

   577 }

   578 

   579 void TestGanesWidgets::test_addRemoveItemsGrid()

   580 {

   581     mWindow = new HbMainWindow;

   582     mWidget = new HgMediawall();

   583     TestModel model;

   584     model.generateItems(2);

   585     mWindow->addView( mWidget );

   586     mWidget->setModel( &model );

   587     mWindow->show();

   588 

   589     QTest::qWait( 2000 );

   590 

   591     model.appendItem();

   592     model.appendItem();

   593     model.removeItems(0);

   594     model.removeItems(3);

   595     model.removeItems(0);

   596     model.removeItems(0);

   597 

   598     QTest::qWait(2000);

   599 

   600     delete mWindow;

   601     mWindow = 0;

   602 }

   603 

   604 void TestGanesWidgets::test_addRemoveItemsCoverflow()

   605 {

   606     mWindow = new HbMainWindow;

   607     mWidget = new HgMediawall();

   608     TestModel model;

   609     model.generateItems(2);

   610     mWindow->addView( mWidget );

   611     mWidget->setModel( &model );

   612     mWindow->show();

   613 

   614     QTest::qWait( 2000 );

   615 

   616     model.appendItem();

   617     model.appendItem();

   618     model.removeItems(0);

   619     model.removeItems(3);

   620     model.removeItems(0);

   621     model.removeItems(0);

   622 

   623     QTest::qWait(2000);

   624 

   625     delete mWindow;

   626     mWindow = 0;

   627 }

   628 

   629 void TestGanesWidgets::test_tap()

   630 {

   631     mWindow = new HbMainWindow;

   632     mWidget = new HgMediawall();

   633     TestModel model;

   634     model.generateItems(50);

   635     mWindow->addView( mWidget );

   636     mWidget->setModel( &model );

   637     mWindow->show();

   638 

   639     QTest::qWait( 2000 );

   640 

   641     QSignalSpy stateSpy( mWidget, SIGNAL( activated(QModelIndex) ) );

   642     QSignalSpy stateSpy2( mWidget, SIGNAL( longPressed(QModelIndex) ) );

   643 

   644     QPointF pos(100,100);

   645     HbAutoTest::mouseClick( (HbAutoTestMainWindow*)mWindow, mWidget, pos, 100 );

   646 

   647     QTest::qWait(1000);

   648 

   649     // Generating gestures doesn't work so enable this condition later.

   650 //    QCOMPARE(stateSpy.count(),1);

   651 

   652     QVERIFY(!mWidget->longPressEnabled());

   653     mWidget->setLongPressEnabled(true);

   654     QVERIFY(mWidget->longPressEnabled());

   655 

   656     HbAutoTest::mousePress( (HbAutoTestMainWindow*)mWindow, mWidget, pos, -1 );

   657     HbAutoTest::mouseRelease( (HbAutoTestMainWindow*)mWindow, mWidget, pos, 2000 );

   658 

   659     // Generating gestures doesn't work so enable this condition later.

   660 //    QCOMPARE( stateSpy2.count(),1 );

   661 

   662     mWidget->setLongPressEnabled(false);

   663     QVERIFY(!mWidget->longPressEnabled());

   664 

   665     QTest::qWait(2000);

   666 

   667     delete mWindow;

   668     mWindow = 0;

   669 }

   670 

   671 void TestGanesWidgets::test_updateData()

   672 {

   673     mWindow = new HbMainWindow;

   674     mWidget = new HgGrid( Qt::Vertical );

   675     TestModel model;

   676     model.generateItems(50);

   677     mWindow->addView( mWidget );

   678     model.mValidData = false;

   679     mWidget->setModel( &model );

   680     mWindow->show();

   681 

   682     QTest::qWait( 2000 );

   683 

   684     model.mValidData = true;

   685     for(int i=0;i<50;i++){

   686         model.changeItem(i);

   687     }

   688 

   689     QTest::qWait(2000);

   690 

   691     delete mWindow;

   692     mWindow = 0;

   693 }

   694 

   695 void TestGanesWidgets::test_currentItemCoverflow()

   696 {

   697     const QPointF pos1(160, 300);

   698     const QPointF pos2(300, 300);

   699     const QPointF pos3(20, 300);

   700 

   701     mWindow = new HbMainWindow;

   702     mWindow->viewport()->grabGesture(Qt::PanGesture);

   703     mWindow->viewport()->grabGesture(Qt::TapGesture); // Add TapAndHoldGesture once it's working

   704     mWidget = new HgMediawall();

   705 

   706     TestModel model;

   707     model.generateItems(50);

   708     mWindow->addView(mWidget);

   709     mWidget->setModel(&model);

   710     mWindow->show();

   711 

   712     QVERIFY(mWidget->selectionModel());

   713     qRegisterMetaType<QModelIndex>("QModelIndex");

   714     QSignalSpy currentItemSpy(mWidget->selectionModel(), SIGNAL(currentChanged(QModelIndex, QModelIndex)));

   715 

   716     QTest::qWait(2000);

   717 

   718     QVERIFY(mWidget->currentIndex() == model.index(0, 0));

   719 

   720     mWidget->setCurrentIndex(model.index(7, 0));

   721     QVERIFY(mWidget->currentIndex() == model.index(7, 0));

   722 

   723     mWidget->setCurrentIndex(QModelIndex());

   724     QVERIFY(!mWidget->currentIndex().isValid());

   725 

   726     currentItemSpy.clear();

   727     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, pos1, 100);

   728     QTest::qWait(1000);

   729     QVERIFY(mWidget->currentIndex() == model.index(0, 0));

   730     QVERIFY(currentItemSpy.count() == 1);

   731     QVERIFY(currentItemSpy.at(0).count() > 0);

   732     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(0, 0));

   733 

   734     currentItemSpy.clear();

   735     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, pos2, 100);

   736     QTest::qWait(1000);

   737     QVERIFY(mWidget->currentIndex() == model.index(1, 0));

   738     QVERIFY(currentItemSpy.count() == 1);

   739     QVERIFY(currentItemSpy.at(0).count() > 0);

   740     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(1, 0));

   741 

   742     currentItemSpy.clear();

   743     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, pos2, 100);

   744     QTest::qWait(1000);

   745     QVERIFY(mWidget->currentIndex() == model.index(2, 0));

   746     QVERIFY(currentItemSpy.count() == 1);

   747     QVERIFY(currentItemSpy.at(0).count() > 0);

   748     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(2, 0));

   749 

   750     currentItemSpy.clear();

   751     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, pos2, 100);

   752     QTest::qWait(1000);

   753     QVERIFY(mWidget->currentIndex() == model.index(3, 0));

   754     QVERIFY(currentItemSpy.count() == 1);

   755     QVERIFY(currentItemSpy.at(0).count() > 0);

   756     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(3, 0));

   757 

   758     currentItemSpy.clear();

   759     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, pos3, 100);

   760     QTest::qWait(1000);

   761     QVERIFY(mWidget->currentIndex() == model.index(2, 0));

   762     QVERIFY(currentItemSpy.count() == 1);

   763     QVERIFY(currentItemSpy.at(0).count() > 0);

   764     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(2, 0));

   765 

   766     currentItemSpy.clear();

   767     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, pos3, 100);

   768     QTest::qWait(1000);

   769     QVERIFY(mWidget->currentIndex() == model.index(1, 0));

   770     QVERIFY(currentItemSpy.count() == 1);

   771     QVERIFY(currentItemSpy.at(0).count() > 0);

   772     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(1, 0));

   773 

   774     currentItemSpy.clear();

   775     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, pos3, 100);

   776     QTest::qWait(1000);

   777     QVERIFY(mWidget->currentIndex() == model.index(0, 0));

   778     QVERIFY(currentItemSpy.count() == 1);

   779     QVERIFY(currentItemSpy.at(0).count() > 0);

   780     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(0, 0));

   781 

   782     currentItemSpy.clear();

   783     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, pos3, 100);

   784     QTest::qWait(1000);

   785     QVERIFY(mWidget->currentIndex() == model.index(0, 0));

   786     QVERIFY(currentItemSpy.count() == 0);

   787 

   788     QTest::qWait(2000);

   789 

   790     delete mWindow;

   791     mWindow = 0;

   792 }

   793 

   794 void TestGanesWidgets::test_currentItemGrid()

   795 {

   796     mWindow = new HbMainWindow;

   797     mWindow->viewport()->grabGesture(Qt::PanGesture);

   798     mWindow->viewport()->grabGesture(Qt::TapGesture); // Add TapAndHoldGesture once it's working

   799     mWidget = new HgGrid( Qt::Vertical);

   800 

   801     TestModel model;

   802     model.generateItems(50);

   803     mWindow->addView(mWidget);

   804     mWidget->setModel(&model);

   805     mWindow->show();

   806 

   807     QVERIFY(mWidget->selectionModel());

   808     qRegisterMetaType<QModelIndex>("QModelIndex");

   809     QSignalSpy currentItemSpy(mWidget->selectionModel(), SIGNAL(currentChanged(QModelIndex, QModelIndex)));

   810 

   811     QTest::qWait(2000);

   812 

   813     QVERIFY(mWidget->currentIndex() == model.index(0, 0));

   814 

   815     mWidget->setCurrentIndex(model.index(7, 0));

   816     QVERIFY(mWidget->currentIndex() == model.index(7, 0));

   817 

   818     mWidget->setCurrentIndex(QModelIndex());

   819     QVERIFY(!mWidget->currentIndex().isValid());

   820 

   821     currentItemSpy.clear();

   822     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos1, 100);

   823     QTest::qWait(1000);

   824     QVERIFY(mWidget->currentIndex() == model.index(1, 0));

   825     QVERIFY(currentItemSpy.count() == 1);

   826     QVERIFY(currentItemSpy.at(0).count() > 0);

   827     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(1, 0));

   828 

   829     currentItemSpy.clear();

   830     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos4, 100);

   831     QTest::qWait(1000);

   832     QVERIFY(mWidget->currentIndex() == model.index(4, 0));

   833     QVERIFY(currentItemSpy.count() == 1);

   834     QVERIFY(currentItemSpy.at(0).count() > 0);

   835     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(4, 0));

   836 

   837     currentItemSpy.clear();

   838     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos4, 100);

   839     QTest::qWait(1000);

   840     QVERIFY(mWidget->currentIndex() == model.index(4, 0));

   841     QVERIFY(currentItemSpy.count() == 0);

   842 

   843     currentItemSpy.clear();

   844     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos8, 100);

   845     QTest::qWait(1000);

   846     QVERIFY(mWidget->currentIndex() == model.index(8, 0));

   847     QVERIFY(currentItemSpy.count() == 1);

   848     QVERIFY(currentItemSpy.at(0).count() > 0);

   849     QVERIFY(qvariant_cast<QModelIndex>(currentItemSpy.at(0).at(0)) == model.index(8, 0));

   850 

   851     QTest::qWait(2000);

   852 

   853     delete mWindow;

   854     mWindow = 0;

   855 }

   856 

   857 void TestGanesWidgets::test_selectionMode()

   858 {

   859     mWindow = new HbMainWindow;

   860     mWindow->viewport()->grabGesture(Qt::PanGesture);

   861     mWindow->viewport()->grabGesture(Qt::TapGesture); // Add TapAndHoldGesture once it's working

   862     mWidget = new HgGrid( Qt::Vertical);

   863 

   864     mWindow->addView(mWidget);

   865     mWindow->show();

   866 

   867     QTest::qWait(2000);

   868 

   869     // Widget does not have selection model yet

   870     QVERIFY(mWidget->selectionModel() == 0);

   871 

   872     // Selection methods should have no effect unless there is a model

   873     mWidget->setSelectionMode(HgWidget::MultiSelection);

   874     QVERIFY(mWidget->selectionMode() == HgWidget::MultiSelection);

   875     QVERIFY(mWidget->selectionModel() == 0);

   876     mWidget->selectAll();

   877     QVERIFY(mWidget->selectionModel() == 0);

   878 

   879     TestModel model;

   880     model.generateItems(9);

   881     mWidget->setModel(&model);

   882     QVERIFY(mWidget->selectionModel() != 0);

   883 

   884     qRegisterMetaType<QItemSelection>("QItemSelection");

   885     QSignalSpy selectionSpy(mWidget->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)));

   886 

   887     QTest::qWait(2000);

   888 

   889     mWidget->setSelectionMode(HgWidget::NoSelection);

   890     QVERIFY(mWidget->selectionMode() == HgWidget::NoSelection);

   891     // Default selection mode: no selection

   892     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos0, 100);

   893     QTest::qWait(1000);

   894     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 0);

   895     QVERIFY(selectionSpy.count() == 0);

   896 

   897     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos1, 100);

   898     QTest::qWait(1000);

   899     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 0);

   900     QVERIFY(selectionSpy.count() == 0);

   901 

   902     mWidget->selectAll();

   903     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 0);

   904     QVERIFY(selectionSpy.count() == 0);

   905 

   906     // Single selection mode: at most 1 item selected at a time

   907     mWidget->setSelectionMode(HgWidget::SingleSelection);

   908     QVERIFY(mWidget->selectionMode() == HgWidget::SingleSelection);

   909     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 0);

   910 

   911     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos1, 100);

   912     QTest::qWait(1000);

   913     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 1);

   914     QVERIFY(mWidget->selectionModel()->isSelected(model.index(1, 0)));

   915     QVERIFY(selectionSpy.count() == 1);

   916     QVERIFY(selectionSpy.at(0).count() > 0);

   917     QItemSelection selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

   918     QVERIFY(selection.indexes().count() == 1);

   919     QVERIFY(selection.contains(model.index(1, 0)));

   920 

   921     selectionSpy.clear();

   922     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos3, 100);

   923     QTest::qWait(1000);

   924     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 1);

   925     QVERIFY(mWidget->selectionModel()->isSelected(model.index(3, 0)));

   926     QVERIFY(selectionSpy.count() == 1);

   927     QVERIFY(selectionSpy.at(0).count() > 1);

   928     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0)); // new selected

   929     QVERIFY(selection.indexes().count() == 1);

   930     QVERIFY(selection.contains(model.index(3, 0)));

   931     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(1)); // deselected

   932     QVERIFY(selection.indexes().count() == 1);

   933     QVERIFY(selection.contains(model.index(1, 0)));

   934 

   935     selectionSpy.clear();

   936     mWidget->clearSelection();

   937     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 0);

   938     QVERIFY(selectionSpy.count() == 1);

   939     QVERIFY(selectionSpy.at(0).count() > 0);

   940     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

   941     QVERIFY(selection.indexes().count() == 0);

   942 

   943     selectionSpy.clear();

   944     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos8, 100);

   945     QTest::qWait(1000);

   946     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 1);

   947     QVERIFY(mWidget->selectionModel()->isSelected(model.index(8, 0)));

   948     QVERIFY(selectionSpy.count() == 1);

   949     QVERIFY(selectionSpy.at(0).count() > 0);

   950     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

   951     QVERIFY(selection.indexes().count() == 1);

   952     QVERIFY(selection.contains(model.index(8, 0)));

   953 

   954     selectionSpy.clear();

   955     // Changing selection mode with default parameter should clear the selection

   956     mWidget->setSelectionMode(HgWidget::ContiguousSelection);

   957     QVERIFY(mWidget->selectionMode() == HgWidget::ContiguousSelection);

   958 

   959     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 0);

   960     QVERIFY(selectionSpy.count() == 1);

   961     QVERIFY(selectionSpy.at(0).count() > 0);

   962     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

   963     QVERIFY(selection.indexes().count() == 0);

   964 

   965     selectionSpy.clear();

   966     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos2, 100);

   967     QTest::qWait(1000);

   968     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 1);

   969     QVERIFY(mWidget->selectionModel()->isSelected(model.index(2, 0)));

   970     QVERIFY(selectionSpy.count() == 1);

   971     QVERIFY(selectionSpy.at(0).count() > 0);

   972     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

   973     QVERIFY(selection.indexes().count() == 1);

   974     QVERIFY(selection.contains(model.index(2, 0)));

   975 

   976     selectionSpy.clear();

   977     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos3, 100);

   978     QTest::qWait(1000);

   979     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 2);

   980     QVERIFY(mWidget->selectionModel()->isSelected(model.index(3, 0)));

   981     QVERIFY(selectionSpy.count() == 1);

   982     QVERIFY(selectionSpy.at(0).count() > 0);

   983     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

   984     QVERIFY(selection.indexes().count() == 1);

   985     QVERIFY(selection.contains(model.index(3, 0)));

   986 

   987     selectionSpy.clear();

   988     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos5, 100);

   989     QTest::qWait(1000);

   990     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 4);

   991     QVERIFY(mWidget->selectionModel()->isSelected(model.index(4, 0)));

   992     QVERIFY(mWidget->selectionModel()->isSelected(model.index(5, 0)));

   993     QVERIFY(selectionSpy.count() == 1);

   994     QVERIFY(selectionSpy.at(0).count() > 0);

   995     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

   996     QVERIFY(selection.indexes().count() == 2);

   997     QVERIFY(selection.contains(model.index(4, 0)));

   998     QVERIFY(selection.contains(model.index(5, 0)));

   999 

  1000     selectionSpy.clear();

  1001     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos0, 100);

  1002     QTest::qWait(1000);

  1003     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 6);

  1004     QVERIFY(mWidget->selectionModel()->isSelected(model.index(0, 0)));

  1005     QVERIFY(mWidget->selectionModel()->isSelected(model.index(1, 0)));

  1006     QVERIFY(selectionSpy.count() == 1);

  1007     QVERIFY(selectionSpy.at(0).count() > 0);

  1008     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

  1009     QVERIFY(selection.indexes().count() == 2);

  1010     QVERIFY(selection.contains(model.index(0, 0)));

  1011     QVERIFY(selection.contains(model.index(1, 0)));

  1012 

  1013     // In contiguous selection mode, clicking a selected item does nothing

  1014     selectionSpy.clear();

  1015     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos5, 100);

  1016     QTest::qWait(1000);

  1017     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 6);

  1018     QVERIFY(selectionSpy.count() == 0);

  1019 

  1020     selectionSpy.clear();

  1021     mWidget->selectAll();

  1022     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 9);

  1023     QVERIFY(selectionSpy.count() == 1);

  1024 

  1025     selectionSpy.clear();

  1026     // Changing selection mode with resetSelection = false should NOT clear the selection

  1027     mWidget->setSelectionMode(HgWidget::MultiSelection, false);

  1028     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 9);

  1029     QVERIFY(selectionSpy.count() == 0);

  1030 

  1031     selectionSpy.clear();

  1032     // In multiselection mode, clicking a selected item deselects it

  1033     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos5, 100);

  1034     QTest::qWait(1000);

  1035     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 8);

  1036     QVERIFY(!(mWidget->selectionModel()->isSelected(model.index(5, 0))));

  1037     QVERIFY(selectionSpy.count() == 1);

  1038     QVERIFY(selectionSpy.at(0).count() > 1);

  1039     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0)); // new selected

  1040     QVERIFY(selection.indexes().count() == 0);

  1041     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(1)); // deselected

  1042     QVERIFY(selection.indexes().count() == 1);

  1043     QVERIFY(selection.contains(model.index(5, 0)));

  1044 

  1045     selectionSpy.clear();

  1046     mWidget->clearSelection();

  1047     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 0);

  1048     QVERIFY(selectionSpy.count() == 1);

  1049     QVERIFY(selectionSpy.at(0).count() > 1);

  1050     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0)); // new selected

  1051     QVERIFY(selection.indexes().count() == 0);

  1052     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(1)); // deselected

  1053     QVERIFY(selection.indexes().count() == 8);

  1054 

  1055     selectionSpy.clear();

  1056     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos3, 100);

  1057     QTest::qWait(1000);

  1058     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 1);

  1059     QVERIFY(mWidget->selectionModel()->isSelected(model.index(3, 0)));

  1060     QVERIFY(selectionSpy.count() == 1);

  1061     QVERIFY(selectionSpy.at(0).count() > 0);

  1062     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

  1063     QVERIFY(selection.indexes().count() == 1);

  1064 

  1065     selectionSpy.clear();

  1066     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos5, 100);

  1067     QTest::qWait(1000);

  1068     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 2);

  1069     QVERIFY(mWidget->selectionModel()->isSelected(model.index(5, 0)));

  1070     QVERIFY(selectionSpy.count() == 1);

  1071     QVERIFY(selectionSpy.at(0).count() > 0);

  1072     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

  1073     QVERIFY(selection.indexes().count() == 1);

  1074     QVERIFY(selection.contains(model.index(5, 0)));

  1075 

  1076     selectionSpy.clear();

  1077     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos8, 100);

  1078     QTest::qWait(1000);

  1079     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 3);

  1080     QVERIFY(mWidget->selectionModel()->isSelected(model.index(8, 0)));

  1081     QVERIFY(selectionSpy.count() == 1);

  1082     QVERIFY(selectionSpy.at(0).count() > 0);

  1083     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0));

  1084     QVERIFY(selection.indexes().count() == 1);

  1085     QVERIFY(selection.contains(model.index(8, 0)));

  1086 

  1087     selectionSpy.clear();

  1088     // Setting the same mode does nothing

  1089     mWidget->setSelectionMode(HgWidget::MultiSelection);

  1090     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 3);

  1091     QVERIFY(selectionSpy.count() == 0);

  1092 

  1093     selectionSpy.clear();

  1094     // Keep the selection, even if it is not suitable for the new selection mode

  1095     mWidget->setSelectionMode(HgWidget::SingleSelection, false);

  1096     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 3);

  1097     QVERIFY(selectionSpy.count() == 0);

  1098 

  1099     selectionSpy.clear();

  1100     // First click resets the selection to a valid setup

  1101     HbAutoTest::mouseClick((HbAutoTestMainWindow*)mWindow, mWidget, grid_portrait_pos5, 100);

  1102     QTest::qWait(1000);

  1103     QVERIFY(mWidget->selectionModel()->selectedIndexes().count() == 1);

  1104     QVERIFY(mWidget->selectionModel()->isSelected(model.index(5, 0)));

  1105     QVERIFY(selectionSpy.count() == 1);

  1106     QVERIFY(selectionSpy.at(0).count() > 1);

  1107     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(0)); // new selected

  1108     QVERIFY(selection.indexes().count() == 0);

  1109     selection = qvariant_cast<QItemSelection>(selectionSpy.at(0).at(1)); // deselected

  1110     QVERIFY(selection.indexes().count() == 2);

  1111     QVERIFY(selection.contains(model.index(3, 0)));

  1112     QVERIFY(selection.contains(model.index(8, 0)));

  1113 

  1114     QTest::qWait(2000);

  1115 

  1116     delete mWindow;

  1117     mWindow = 0;

  1118 }

  1119 

  1120 void TestGanesWidgets::test_selectionModel()

  1121 {

  1122     mWindow = new HbMainWindow;

  1123     mWindow->viewport()->grabGesture(Qt::PanGesture);

  1124     mWindow->viewport()->grabGesture(Qt::TapGesture); // Add TapAndHoldGesture once it's working

  1125     mWidget = new HgGrid( Qt::Vertical);

  1126     TestModel model;

  1127     model.generateItems(9);

  1128     mWidget->setModel(&model);

  1129     mWindow->addView(mWidget);

  1130     mWindow->show();

  1131     QTest::qWait(2000);

  1132 

  1133     QVERIFY(mWidget->selectionModel() != 0);

  1134