1 /*

     2 * Copyright (c) 2009 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:

    15 *

    16 */

    17 

    18 #include <HbMainWindow>

    19 #include <HbInstance>

    20 #include <HbView>

    21 

    22 #include "t_hsdomainmodel.h"

    23 #include "hspage.h"

    24 #include "hsscene.h"

    25 #include "hsdomainmodeldatastructures.h"

    26 #include "hswidgethost.h"

    27 #include "hswidgetpositioningonwidgetadd.h"

    28 #include "hswidgetcomponent.h"

    29 #include "hsconfiguration.h"

    30 #include "hsgui.h"

    31 #include "hspagevisual.h"

    32 #include "hswidgetpositioningonorientationchange.h"

    33 

    34 void TestHsDomainModel::testHsPage()

    35 {

    36     HsPageData pageData;

    37     HsPage *page=HsPage::createInstance(pageData);

    38     QVERIFY(page->databaseId());

    39     QVERIFY(page->load());

    40     QCOMPARE(page->widgets().count(),0);

    41 

    42     // we haven't added this to scene.

    43     QCOMPARE(page->pageIndex(),-1);

    44 

    45     QVERIFY(page->isRemovable());

    46     page->setRemovable(false);

    47     QVERIFY(!page->isRemovable());

    48     page->setRemovable(true);

    49     QVERIFY(page->isRemovable());

    50     delete page;

    51 }

    52 

    53 

    54 void TestHsDomainModel::testHsPageLoad()

    55 {

    56     HsPage *page = new HsPage();

    57     QVERIFY(!page->load());

    58     delete page;

    59 

    60     HsPageData pageData;

    61     pageData.indexPosition = 0;

    62     page = HsPage::createInstance(pageData);

    63     QVERIFY(page);

    64     int pageId = page->databaseId();

    65     delete page;

    66 

    67     page = new HsPage();

    68     page->setDatabaseId(pageId);

    69     QVERIFY(page->load());

    70     QVERIFY(page->wallpaper());

    71     QVERIFY(page->deleteFromDatabase());

    72     delete page;

    73 

    74     page = HsPage::createInstance(pageData);

    75     QVERIFY(page);

    76     pageId = page->databaseId();

    77     delete page;

    78     page = new HsPage();

    79     page->setDatabaseId(pageId);

    80     QVERIFY(page->load());

    81 

    82     QVERIFY(page->deleteFromDatabase());

    83     delete page;

    84 

    85 }

    86 

    87 void TestHsDomainModel::testHsPageContentRects()

    88 {

    89     HsPageData pageData;

    90     pageData.indexPosition = 0;

    91     HsPage *page = HsPage::createInstance(pageData);

    92     QVERIFY(page->databaseId());

    93     QVERIFY(page->load());

    94     QCOMPARE(page->widgets().count(),0);

    95     HsScene::instance()->addPage(page);

    96     HsGui *stored = HsGui::takeInstance();

    97     

    98     HbInstance::instance();

    99     HbMainWindow mainWindow;        

   100     HbView *view = mainWindow.addView(page->visual());

   101     mainWindow.views().first()->setContentFullScreen();

   102     mainWindow.show();

   103     HsGui *gui = HsGui::instance();

   104     // crashes symbian test

   105 #ifndef Q_OS_SYMBIAN    

   106     QEventLoop waitUntilMainWindowCreated;

   107     QTimer eventLoopTimer;

   108     eventLoopTimer.setInterval(15000);

   109     eventLoopTimer.setSingleShot(true);    

   110     connect(&mainWindow, SIGNAL(viewReady()),

   111             &waitUntilMainWindowCreated, SLOT(quit()));

   112     connect(&eventLoopTimer, SIGNAL(timeout()),

   113             &waitUntilMainWindowCreated, SLOT(quit()));

   114     eventLoopTimer.start();

   115     waitUntilMainWindowCreated.exec();

   116     eventLoopTimer.stop();

   117 #endif        

   118     QRectF layoutRect = mainWindow.layoutRect();

   119     qreal pageMargin = HSCONFIGURATION_GET(pageMargin);

   120     QRectF expectecRect;

   121 

   122     //Test global rect

   123     expectecRect = layoutRect;

   124     expectecRect.setTop(64);

   125     expectecRect.adjust(pageMargin, pageMargin, -pageMargin, -pageMargin);

   126     QRectF contentGeometry = page->contentGeometry();

   127     QCOMPARE(contentGeometry, expectecRect);

   128 

   129     //Test global rect at different orientation - improves branch coverage

   130     expectecRect = layoutRect;

   131     expectecRect.setWidth(layoutRect.height());

   132     expectecRect.setHeight(layoutRect.width());

   133     expectecRect.setTop(64);

   134     expectecRect.adjust(pageMargin, pageMargin, -pageMargin, -pageMargin);

   135     Qt::Orientation orientation =

   136         //HsScene::instance()->mainWindow()->orientation() ==

   137         gui->orientation() ==

   138             Qt::Vertical ? Qt::Horizontal : Qt::Vertical;

   139     contentGeometry = page->contentGeometry(orientation);

   140     QCOMPARE(contentGeometry, expectecRect);

   141 

   142     //Test local rect

   143     expectecRect = layoutRect;

   144     expectecRect.setTop(64);

   145     expectecRect.moveTopLeft(QPointF(0,0));

   146     expectecRect.adjust(pageMargin, pageMargin, -pageMargin, -pageMargin);

   147     QRectF contentRect = page->contentRect();

   148     QCOMPARE(contentRect, expectecRect);

   149     

   150     mainWindow.hide();

   151     mainWindow.removeView(view);

   152     delete HsGui::takeInstance();

   153     if(stored) {

   154         HsGui::setInstance(stored);

   155     }

   156     HsScene::instance()->removePage(page);

   157     delete page;

   158 }

   159 

   160 void TestHsDomainModel::testHsPageAddRemoveWidget()

   161 {

   162     HsWidgetPositioningOnWidgetAdd::setInstance(

   163         new HsAnchorPointInBottomRight);

   164 

   165     HsPageData pageData;

   166     pageData.indexPosition = 0;

   167     HsPage *page = HsPage::createInstance(pageData);

   168     QVERIFY(page);

   169     int pageId = page->databaseId();

   170 

   171     HsWidgetData widgetData;

   172     widgetData.pageId = pageId;

   173     widgetData.uri = "uri1";

   174     HsWidgetHost *widget = HsWidgetHost::createInstance(widgetData);

   175     QVERIFY(widget);

   176 

   177     widget->setPage(page);

   178     QVERIFY(!page->addNewWidget(0));

   179     QVERIFY(page->addNewWidget(widget));

   180     QVERIFY(page->addNewWidget(widget));

   181     QCOMPARE(page->newWidgets().count(), 1);

   182     QCOMPARE(page->widgets().count(), 0);

   183 

   184     page->layoutNewWidgets();

   185     QCOMPARE(page->newWidgets().count(), 0);

   186     QCOMPARE(page->widgets().count(), 1);

   187     QCOMPARE(page->newWidgets().count(), 0);

   188     QCOMPARE(page->widgets().count(), 1);  

   189     page->resetNewWidgets();  

   190 

   191     HsWidgetHost *widget2 = HsWidgetHost::createInstance(widgetData);

   192     QVERIFY(widget2);

   193     widget2->setPage(page);

   194     QVERIFY(page->addNewWidget(widget2));

   195     QCOMPARE(page->newWidgets().count(),1);

   196     QCOMPARE(page->widgets().count(),1);

   197 

   198     // test layouting for landscape orientation

   199     HsGui::instance()->setOrientation(Qt::Horizontal);

   200     // active widget for branch testing

   201     HsScene::instance()->setActiveWidget(widget);

   202     page->layoutNewWidgets();

   203     // set active widget to original

   204     HsScene::instance()->setActiveWidget(0);

   205 

   206     QCOMPARE(page->newWidgets().count(), 0);

   207     QCOMPARE(page->widgets().count(), 2);

   208     QCOMPARE(page->newWidgets().count(), 0);

   209     HsGui::instance()->setOrientation(Qt::Vertical);

   210 

   211     page->layoutNewWidgets();

   212     QCOMPARE(page->newWidgets().count(), 0);

   213     QCOMPARE(page->widgets().count(), 2);

   214 

   215     QVERIFY(!page->removeWidget(0));

   216     QVERIFY(page->removeWidget(widget2));

   217 

   218     delete page;

   219 

   220     page = new HsPage();

   221     page->setDatabaseId(pageId);

   222     QVERIFY(page->load());

   223     QVERIFY(page->deleteFromDatabase());

   224     delete page;

   225 

   226     HsWidgetPositioningOnWidgetAdd::setInstance(0);

   227 

   228 }

   229 

   230 

   231 void TestHsDomainModel::testHsPageAddExistingWidget()

   232 {

   233     HsWidgetPositioningOnWidgetAdd::setInstance(

   234         new HsAnchorPointInBottomRight);

   235 

   236     HsPageData pageData;

   237 

   238     pageData.indexPosition = 0;

   239     HsPage *page = HsPage::createInstance(pageData);

   240     QVERIFY(page);

   241     int pageId = page->databaseId();

   242 

   243     pageData.indexPosition = 1;

   244     HsPage *page2 = HsPage::createInstance(pageData);

   245     QVERIFY(page2);

   246     int pageId2 = page2->databaseId();

   247 

   248     HsWidgetData widgetData;

   249     widgetData.pageId = pageId;

   250     widgetData.uri = "mockwidgetplugin";

   251 

   252     HsWidgetHost *widget = HsWidgetHost::createInstance(widgetData);

   253     QVERIFY(widget);

   254     widget->setPage(page);

   255     QVERIFY(page->addNewWidget(widget));

   256 

   257     HsWidgetHost *widget2 = HsWidgetHost::createInstance(widgetData);

   258     QVERIFY(widget2);

   259     widget2->setPage(page);

   260     QVERIFY(page->addNewWidget(widget2));

   261 

   262     // coverages up with active widget

   263     HsScene::instance()->setActiveWidget(widget);

   264     page->layoutNewWidgets();

   265     QCOMPARE(page->widgets().count(), 2);

   266     HsScene::instance()->setActiveWidget(0);

   267 

   268     QVERIFY(page->removeWidget(widget2));

   269     QVERIFY(page2->addExistingWidget(widget2));

   270     QVERIFY(page2->addExistingWidget(widget2));

   271 

   272     QVERIFY(!page->addExistingWidget(NULL));

   273 

   274     delete page;

   275 

   276     page = new HsPage();

   277     page->setDatabaseId(pageId);

   278     QVERIFY(page->load());

   279     // Widget doesn't have presentation yet.    

   280     QCOMPARE(page->widgets().count(), 0); 

   281     QCOMPARE(page->mNewWidgets.count(), 1);

   282     page2 = new HsPage();

   283     page2->setDatabaseId(pageId2);

   284     QVERIFY(page2->load());

   285     // Widget doesn't have presentation yet.

   286     QCOMPARE(page2->widgets().count(), 0);

   287     QCOMPARE(page2->mNewWidgets.count(), 1);

   288     delete page;

   289     delete page2;

   290 

   291     HsWidgetPositioningOnWidgetAdd::setInstance(0);

   292 

   293 }

   294 

   295 

   296 void TestHsDomainModel::testHsPageWidgetFinished()

   297 {

   298     HsWidgetPositioningOnWidgetAdd::setInstance(

   299         new HsAnchorPointInBottomRight);

   300 

   301     HsPageData pageData;

   302     HsPage *page=HsPage::createInstance(pageData);

   303     QVERIFY(page);

   304     int pageId = page->databaseId();

   305     HsScene::instance()->mActivePage = page;

   306 

   307     HsWidgetData widgetData;

   308     widgetData.pageId = pageId;

   309     widgetData.uri = "mockwidgetplugin";

   310 

   311     HsWidgetHost *widget = HsWidgetHost::createInstance(widgetData);

   312     QVERIFY(widget);

   313     widget->setPage(page);

   314     widget->startWidget();

   315     QVERIFY(widget->mStateMachine->isRunning());

   316     QVERIFY(page->addNewWidget(widget));

   317     page->layoutNewWidgets();

   318 

   319     widget->onFinished();

   320     qApp->processEvents();

   321 

   322     QCOMPARE(page->newWidgets().count(),0);

   323     QCOMPARE(page->widgets().count(),0);

   324 

   325     // new widget

   326     widget = HsWidgetHost::createInstance(widgetData);

   327     QVERIFY(widget);

   328     widget->setPage(page);

   329     widget->startWidget();

   330     QVERIFY(widget->mStateMachine->isRunning());

   331     QVERIFY(page->addNewWidget(widget));

   332     QCOMPARE(page->newWidgets().count(),1);

   333     QCOMPARE(page->widgets().count(),0);

   334 

   335     widget->onFinished();

   336     qApp->processEvents();

   337 

   338     QCOMPARE(page->newWidgets().count(),0);

   339     QCOMPARE(page->widgets().count(),0);

   340 

   341     delete page;

   342 

   343     HsWidgetPositioningOnWidgetAdd::setInstance(0);

   344 }

   345 

   346 void TestHsDomainModel::testHsPageIsActivePage()

   347 {

   348     HsPageData pageData;

   349     pageData.indexPosition = 0;

   350     HsPage *page = HsPage::createInstance(pageData);

   351     QVERIFY(page);

   352 

   353     QVERIFY(!page->isActivePage());

   354     QVERIFY(page->isDefaultPage());

   355     delete page;

   356 }

   357 

   358 void TestHsDomainModel::testHsPageWidgetSignals()

   359 {

   360     HsPageData pageData;

   361     HsPage *page = HsPage::createInstance(pageData);

   362     QVERIFY(page);

   363 

   364     HsWidgetData widgetData;

   365     widgetData.pageId = page->databaseId();

   366     widgetData.uri = "mockwidgetplugin";

   367     HsWidgetHost *widget = HsWidgetHost::createInstance(widgetData);

   368     QVERIFY(widget);

   369 

   370     page->addExistingWidget(widget);

   371     widget->setPage(page);

   372     widget->startWidget();

   373 

   374     QCOMPARE(page->mWidgets.count(), 1);

   375     QCOMPARE(page->mUnavailableWidgets.count(), 0);

   376 

   377     emit widget->mComponent->unavailable();

   378 

   379     QCOMPARE(page->mWidgets.count(), 0);

   380     QCOMPARE(page->mUnavailableWidgets.count(), 1);

   381 

   382     emit widget->mComponent->available();

   383 

   384     QCOMPARE(page->mWidgets.count(), 1);

   385     QCOMPARE(page->mUnavailableWidgets.count(), 0);

   386 

   387     // test unavailability when new widgets exists

   388     HsWidgetHost *widget2 = HsWidgetHost::createInstance(widgetData);

   389     page->addNewWidget(widget2);

   390     widget2->setPage(page);

   391     widget2->startWidget();

   392     QCOMPARE(page->mWidgets.count(), 1);

   393     QCOMPARE(page->mNewWidgets.count(), 1);

   394     QCOMPARE(page->mUnavailableWidgets.count(), 0);

   395     emit widget2->mComponent->unavailable();

   396     QCOMPARE(page->mWidgets.count(), 0);

   397     QCOMPARE(page->mNewWidgets.count(), 0);

   398     QCOMPARE(page->mUnavailableWidgets.count(), 2);

   399     page->removeWidget(widget);

   400     page->removeWidget(widget2);

   401 

   402     delete page;

   403 }

   404 

   405 void TestHsDomainModel::testHsPageOrientationChange()

   406 {

   407    HsWidgetPositioningOnWidgetAdd::setInstance(

   408         new HsAnchorPointInBottomRight);

   409 

   410     HsWidgetPositioningOnOrientationChange::setInstance(

   411         new HsAdvancedWidgetPositioningOnOrientationChange);

   412 

   413     HsPageData pageData;

   414     HsPage *page = HsPage::createInstance(pageData);

   415     QVERIFY(page);

   416     

   417     // test when no widgets on page

   418     page->onOrientationChanged(Qt::Horizontal);

   419 

   420     // add existing widget

   421     HsWidgetData widgetData;

   422     widgetData.pageId = page->databaseId();

   423     widgetData.uri = "mockwidgetplugin";

   424     HsWidgetHost *existingWidget = HsWidgetHost::createInstance(widgetData);

   425     QVERIFY(existingWidget);

   426     page->addExistingWidget(existingWidget);

   427 

   428     // add new widget without presentation

   429     HsWidgetData widgetData2;

   430     widgetData2.pageId = page->databaseId();

   431     widgetData2.uri = "mockwidgetplugintoosmall";

   432     HsWidgetHost *newWidget = HsWidgetHost::createInstance(widgetData2);

   433     QVERIFY(newWidget);

   434     page->addNewWidget(newWidget);

   435     newWidget->removePresentation(Qt::Horizontal);

   436 

   437     page->onOrientationChanged(Qt::Horizontal);

   438     page->onOrientationChanged(Qt::Vertical);

   439 

   440     delete page;

   441     HsWidgetPositioningOnOrientationChange::setInstance(0);

   442     HsWidgetPositioningOnWidgetAdd::setInstance(0);

   443 }

   444 

   445 void TestHsDomainModel::testHsPageDeleteFromDatabase()

   446 {

   447     HsWidgetPositioningOnWidgetAdd::setInstance(

   448         new HsAnchorPointInBottomRight);

   449 

   450     HsPageData pageData;

   451     pageData.indexPosition = 0;

   452     HsPage *page = HsPage::createInstance(pageData);

   453     HsWidgetData widgetData;

   454     widgetData.pageId = page->databaseId();

   455     widgetData.uri = "mockwidgetplugin";

   456     HsWidgetHost *widget = HsWidgetHost::createInstance(widgetData);

   457 

   458     // new widgets not deleted

   459     page->addNewWidget(widget);

   460     QCOMPARE(page->newWidgets().count(), 1);

   461     page->deleteFromDatabase();

   462     QCOMPARE(page->newWidgets().count(), 0);

   463 

   464     // widgets not deleted

   465     page->addNewWidget(widget);

   466 

   467     // test set online when new widgets exists

   468     page->setOnline();

   469     page->layoutNewWidgets();

   470     // test show widgets

   471     page->showWidgets();

   472     // test hide widgets

   473     page->hideWidgets();

   474     // test set online when widgets exists

   475     page->setOnline();

   476 

   477     QCOMPARE(page->mWidgets.count(), 1);

   478     QVERIFY(page->deleteFromDatabase());

   479     QCOMPARE(page->mWidgets.count(), 0);

   480 

   481     // unavailable widgets not deleted

   482     page->mUnavailableWidgets.append(widget);

   483     QCOMPARE(page->mUnavailableWidgets.count(), 1);

   484     QVERIFY(page->deleteFromDatabase());

   485     QCOMPARE(page->mUnavailableWidgets.count(), 0);

   486 

   487     delete widget;

   488     delete page;

   489     

   490 }

   491 

   492 void TestHsDomainModel::testHsPageOnPageMarginChanged()

   493 {

   494     HsWidgetPositioningOnWidgetAdd::setInstance(

   495         new HsAnchorPointInBottomRight);

   496 

   497 

   498     //Create empty page

   499     HsPageData pageData;

   500     pageData.indexPosition = 0;

   501     HsPage *page = HsPage::createInstance(pageData);

   502     QVERIFY(page);

   503     int pageId = page->databaseId();

   504     page->onPageMarginChanged("dummy");

   505     page->onPageMarginChanged("pageMargin"); //No widgets

   506 

   507     //Add first widget

   508     HsWidgetData widgetData;

   509     widgetData.pageId = pageId;

   510     widgetData.uri = "uri1";

   511     HsWidgetHost *widget = HsWidgetHost::createInstance(widgetData);

   512     QVERIFY(widget);

   513     widget->setPage(page);

   514     QVERIFY(!page->addNewWidget(0));

   515     QVERIFY(page->addNewWidget(widget));

   516     QVERIFY(page->addNewWidget(widget));

   517     QCOMPARE(page->newWidgets().count(), 1);

   518     QCOMPARE(page->widgets().count(), 0);

   519     page->onPageMarginChanged("pageMargin"); // Only mNewWidgets

   520     page->layoutNewWidgets();

   521     QCOMPARE(page->newWidgets().count(), 0);

   522     QCOMPARE(page->widgets().count(), 1);

   523     QCOMPARE(page->newWidgets().count(), 0);

   524     QCOMPARE(page->widgets().count(), 1);  

   525     page->resetNewWidgets();   

   526 

   527     //Add second widget

   528     HsWidgetHost *widget2 = HsWidgetHost::createInstance(widgetData);

   529     QVERIFY(widget2);

   530     widget2->setPage(page);

   531     QVERIFY(page->addNewWidget(widget2));

   532     QCOMPARE(page->newWidgets().count(),1);

   533     QCOMPARE(page->widgets().count(),1);

   534     page->onPageMarginChanged("pageMargin"); // Both mWidgets and mNewWidgets

   535     page->layoutNewWidgets();

   536     page->onPageMarginChanged("pageMargin"); //Only mWidgets

   537     QCOMPARE(page->newWidgets().count(), 0);

   538     QCOMPARE(page->widgets().count(), 2);

   539 

   540     delete page;

   541 

   542     HsWidgetPositioningOnWidgetAdd::setInstance(0);

   543 }

   544 

   545 void TestHsDomainModel::testHsPageIndex()

   546 {

   547     HsPageData pageData;

   548     pageData.indexPosition = 0;

   549     HsPage *page = HsPage::createInstance(pageData);

   550     QVERIFY(page->load());

   551     QCOMPARE(page->mPageVisual->pageIndex(),-1);

   552     HsScene::instance()->addPage(page);

   553     QCOMPARE(page->mPageVisual->pageIndex(),0);

   554 

   555     pageData.indexPosition = 1;

   556     HsPage *page2 = HsPage::createInstance(pageData);

   557     QVERIFY(page2->load());

   558     HsScene::instance()->addPage(page2);

   559     QCOMPARE(page2->mPageVisual->pageIndex(),1);

   560     

   561     HsScene::instance()->removePage(page);

   562     delete page;

   563     HsScene::instance()->removePage(page2);

   564     delete page2;

   565 }

   566