homescreenapp/stateplugins/hsapplibrarystateplugin/src/hsmenuview.cpp
changeset 39 4e8ebe173323
parent 36 cdae8c6c3876
child 46 23b5d6a29cce
equal deleted inserted replaced
36:cdae8c6c3876 39:4e8ebe173323
    50  Builds UI objects
    50  Builds UI objects
    51  Sets up signals connections.
    51  Sets up signals connections.
    52 
    52 
    53  \param window Main window.
    53  \param window Main window.
    54  */
    54  */
    55 HsMenuView::HsMenuView(HbMainWindow *window):
    55 HsMenuView::HsMenuView():
    56     mBuilder(),
    56     mBuilder(),
    57     mWindow(window),
       
    58     mModel(NULL),
    57     mModel(NULL),
    59     mMenuSearch(this),
    58     mFirstVisibleIndex(),
       
    59     mLastVisibleIndex(),
    60     mToolBarActionGroup(new QActionGroup(mBuilder.toolBar())),
    60     mToolBarActionGroup(new QActionGroup(mBuilder.toolBar())),
    61     mMenuMode(NormalHsMenuMode)
    61     mMenuMode(NormalHsMenuMode),
       
    62     mProxyModel(new QSortFilterProxyModel(this))
    62 {
    63 {
    63     setUpToolBar();
    64     setUpToolBar();
    64     connectItemViewsSignals();
    65     connectItemViewsSignals();
       
    66 
       
    67     mProxyModel->setFilterRole(CaItemModel::TextRole);
       
    68     mProxyModel->setFilterKeyColumn(1);
       
    69     mProxyModel->setSortRole(CaItemModel::TextRole);
    65 }
    70 }
    66 
    71 
    67 /*!
    72 /*!
    68  Destructor
    73  Destructor
    69 
    74 
    96     }
   101     }
    97     HSMENUTEST_FUNC_EXIT("HsMenuView::setModel");
   102     HSMENUTEST_FUNC_EXIT("HsMenuView::setModel");
    98 }
   103 }
    99 
   104 
   100 /*!
   105 /*!
   101  Sets model for item view.
   106  Sets model for item view without connecting scroll signals
   102 
   107 
   103  \return Model shown by item view.
   108  \param model Model to show by item view
   104  */
   109  */
   105 const HsMenuItemModel *HsMenuView::model() const
   110 void HsMenuView::setModelToView(QAbstractItemModel *model)
   106 {
   111 {
   107     return mModel;
   112     HSMENUTEST_FUNC_ENTRY("HsMenuView::setModelToView");
       
   113 
       
   114     mBuilder.listView()->setModel(model);
       
   115 
       
   116     HSMENUTEST_FUNC_EXIT("HsMenuView::setModelToView");
   108 }
   117 }
   109 
   118 
   110 /*!
   119 /*!
   111     Sets label text to be shown when label is enabled.
   120     Sets label text to be shown when label is enabled.
   112     \param label Label text.
   121     \param label Label text.
   134         mBuilder.listView()->scrollTo(index, hint);
   143         mBuilder.listView()->scrollTo(index, hint);
   135     }
   144     }
   136     HSMENUTEST_FUNC_EXIT("HsAllCollectionsState::scrollTo");
   145     HSMENUTEST_FUNC_EXIT("HsAllCollectionsState::scrollTo");
   137 }
   146 }
   138 
   147 
   139 /*!
       
   140      Scrolls item view to requested item.
       
   141      Does not close search panel.
       
   142      \param index The index of the item the view is to be scrolled.
       
   143      \param hint Where the target item should be positioned in visible area
       
   144      after scroll.
       
   145  */
       
   146 void HsMenuView::scrollToWithoutHidingSearchPanel(const QModelIndex &index,
       
   147         HbAbstractItemView::ScrollHint hint)
       
   148 {
       
   149     HSMENUTEST_FUNC_ENTRY("HsMenuView::scrollToWithoutHidingSearchPanel");
       
   150     hideSearchPanelOnScrolling(false);
       
   151     scrollTo(index, hint);
       
   152     hideSearchPanelOnScrolling(true);
       
   153     HSMENUTEST_FUNC_EXIT("HsMenuView::scrollToWithoutHidingSearchPanel");
       
   154 }
       
   155 
   148 
   156 /*!
   149 /*!
   157     Makes the UI to show or hide view label.
   150     Makes the UI to show or hide view label.
   158      \param visible When true label will be shown,
   151      \param visible When true label will be shown,
   159      otherwise it will be hidden.
   152      otherwise it will be hidden.
   174  */
   167  */
   175 void HsMenuView::setSearchPanelVisible(bool visible)
   168 void HsMenuView::setSearchPanelVisible(bool visible)
   176 {
   169 {
   177     HSMENUTEST_FUNC_ENTRY("HsMenuView::setSearchPanelVisible");
   170     HSMENUTEST_FUNC_ENTRY("HsMenuView::setSearchPanelVisible");
   178     if (mBuilder.searchPanel()->isVisible() != visible) {
   171     if (mBuilder.searchPanel()->isVisible() != visible) {
   179         const static Hb::SceneItems statusPaneItems(
       
   180             Hb::SecondarySoftKeyItem
       
   181             | Hb::TitlePaneItem
       
   182             | Hb::IndicatorItems);
       
   183 
       
   184         if (visible) {
   172         if (visible) {
   185             mWindow->hideItems(statusPaneItems);
   173             mFirstVisibleIndex = firstVisibleItemIndex();
       
   174             mBuilder.setSearchPanelVisible(visible);
       
   175             mBuilder.view()->hideItems(Hb::AllItems);
   186             connectSearchPanelSignals();
   176             connectSearchPanelSignals();
       
   177 
   187         } else {
   178         } else {
   188             mWindow->showItems(statusPaneItems);
   179             mLastVisibleIndex = firstVisibleItemIndex();
       
   180             mBuilder.view()->showItems(Hb::AllItems);
       
   181             mBuilder.setSearchPanelVisible(visible);
   189             disconnectSearchPanelSignals();
   182             disconnectSearchPanelSignals();
   190         }
   183         }
   191 
       
   192         mBuilder.setSearchPanelVisible(visible);
       
   193     }
   184     }
   194     HSMENUTEST_FUNC_EXIT("HsMenuView::setSearchPanelVisible");
   185     HSMENUTEST_FUNC_EXIT("HsMenuView::setSearchPanelVisible");
   195 }
   186 }
   196 
   187 
   197 /*!
   188 /*!
   265 {
   256 {
   266     HSMENUTEST_FUNC_ENTRY("HsMenuView::showSearchPanel");
   257     HSMENUTEST_FUNC_ENTRY("HsMenuView::showSearchPanel");
   267     setSearchPanelVisible(true);
   258     setSearchPanelVisible(true);
   268     HSMENUTEST_FUNC_EXIT("HsMenuView::showSearchPanel");
   259     HSMENUTEST_FUNC_EXIT("HsMenuView::showSearchPanel");
   269 }
   260 }
       
   261 #ifdef COVERAGE_MEASUREMENT
       
   262 #pragma CTC SKIP
       
   263 #endif //COVERAGE_MEASUREMENT skipped: it doubles other method
   270 
   264 
   271 /*!
   265 /*!
   272  * Makes search panel visible.
   266  * Makes search panel visible.
   273  * Equivalent to \a setSearchPanelVisible(false).
   267  * Equivalent to \a setSearchPanelVisible(false).
   274  */
   268  */
   276 {
   270 {
   277     HSMENUTEST_FUNC_ENTRY("HsMenuView::hideSearchPanel");
   271     HSMENUTEST_FUNC_ENTRY("HsMenuView::hideSearchPanel");
   278     setSearchPanelVisible(false);
   272     setSearchPanelVisible(false);
   279     HSMENUTEST_FUNC_EXIT("HsMenuView::hideSearchPanel");
   273     HSMENUTEST_FUNC_EXIT("HsMenuView::hideSearchPanel");
   280 }
   274 }
       
   275 #ifdef COVERAGE_MEASUREMENT
       
   276 #pragma CTC ENDSKIP
       
   277 #endif //COVERAGE_MEASUREMENT
   281 
   278 
   282 /*!
   279 /*!
   283  Scrolls item view to requested row.
   280  Scrolls item view to requested row.
   284  If search panel is open it will be closed after the fuction call.
   281  If search panel is open it will be closed after the fuction call.
   285  \param row The row which is to get on the top of item view.
   282  \param row The row which is to get on the top of item view.
   292     HSMENUTEST_FUNC_EXIT("HsMenuView::scrollToRow");
   289     HSMENUTEST_FUNC_EXIT("HsMenuView::scrollToRow");
   293 }
   290 }
   294 
   291 
   295 /*!
   292 /*!
   296      Converts scroll hints.
   293      Converts scroll hints.
   297      \param Qt hint Where the target item should be positioned in visible area
   294      \param Qt hint Where the target item should be positioned in
   298      after scroll.
   295      visible area after scroll.
   299      \return Qrbit version of hint
   296      \return Qrbit version of hint
   300  */
   297  */
   301 HbAbstractItemView::ScrollHint HsMenuView::convertScrollHint(
   298 HbAbstractItemView::ScrollHint HsMenuView::convertScrollHint(
   302         QAbstractItemView::ScrollHint hint)
   299         QAbstractItemView::ScrollHint hint)
   303 {
   300 {
   341     disconnect(listView, SIGNAL(longPressed(HbAbstractViewItem *, QPointF)),
   338     disconnect(listView, SIGNAL(longPressed(HbAbstractViewItem *, QPointF)),
   342                this, SIGNAL(longPressed(HbAbstractViewItem *, QPointF)));
   339                this, SIGNAL(longPressed(HbAbstractViewItem *, QPointF)));
   343 }
   340 }
   344 
   341 
   345 /*!
   342 /*!
       
   343  Connects \a activated and \a longPressed signals coming from search list
       
   344  view to emit corresponding signal of this object with translated model index
       
   345 */
       
   346 void HsMenuView::connectSearchItemViewsSignals()
       
   347 {
       
   348     const HbListView *const listView = mBuilder.listView();
       
   349 
       
   350     connect(listView, SIGNAL(activated(QModelIndex)),
       
   351             this, SLOT(activatedProxySlot(QModelIndex)));
       
   352     connect(listView, SIGNAL(longPressed(HbAbstractViewItem *, QPointF)),
       
   353             this, SLOT(longPressedProxySlot(HbAbstractViewItem *, QPointF)));
       
   354 
       
   355 }
       
   356 
       
   357 /*!
       
   358  Disconnects \a activated and \a longPressed signals coming from list
       
   359  view from to emit corresponding signal
       
   360  of this object with translated model index
       
   361 */
       
   362 void HsMenuView::disconnectSearchItemViewsSignals()
       
   363 {
       
   364     const HbListView *const listView = mBuilder.listView();
       
   365 
       
   366     disconnect(listView, SIGNAL(activated(QModelIndex)),
       
   367                this, SLOT(activatedProxySlot(QModelIndex)));
       
   368     disconnect(listView, SIGNAL(longPressed(HbAbstractViewItem *, QPointF)),
       
   369                this, SLOT(longPressedProxySlot(HbAbstractViewItem *, QPointF)));
       
   370 }
       
   371 
       
   372 /*!
   346  Connects model's \a scrollTo signal with the object \a scrollToRow slot.
   373  Connects model's \a scrollTo signal with the object \a scrollToRow slot.
   347 */
   374 */
   348 void HsMenuView::connectModelSignals()
   375 void HsMenuView::connectModelSignals()
   349 {
   376 {
   350     connect(mModel,SIGNAL(scrollTo(int,QAbstractItemView::ScrollHint)),
   377     connect(mModel,SIGNAL(scrollTo(int,QAbstractItemView::ScrollHint)),
   364  Connects signals \a exitClicked and \a criteriaChanged emitted
   391  Connects signals \a exitClicked and \a criteriaChanged emitted
   365  by search panel with handling slots of the object or its members
   392  by search panel with handling slots of the object or its members
   366 */
   393 */
   367 void HsMenuView::connectSearchPanelSignals()
   394 void HsMenuView::connectSearchPanelSignals()
   368 {
   395 {
       
   396     disconnectModelSignals();    
       
   397     disconnectItemViewsSignals();
       
   398 
       
   399     searchBegins();
       
   400     connectSearchItemViewsSignals();
       
   401 
   369     connect(mBuilder.searchPanel(), SIGNAL(exitClicked()),
   402     connect(mBuilder.searchPanel(), SIGNAL(exitClicked()),
   370             this, SLOT(hideSearchPanel()));
   403             this, SLOT(hideSearchPanel()));
   371 
       
   372     connect(mBuilder.searchPanel(), SIGNAL(criteriaChanged(QString)),
   404     connect(mBuilder.searchPanel(), SIGNAL(criteriaChanged(QString)),
   373             &mMenuSearch, SLOT(findItem(QString)));
   405             this, SLOT(findItem(QString)));
   374 
   406     scrollTo(mProxyModel->mapFromSource(mFirstVisibleIndex),
   375     hideSearchPanelOnScrolling(true);
   407              HbAbstractItemView::PositionAtTop);
       
   408 
   376 }
   409 }
   377 
   410 
   378 /*!
   411 /*!
   379  Disconnects signals \a exitClicked and \a criteriaChanged emitted
   412  Disconnects signals \a exitClicked and \a criteriaChanged emitted
   380  by search panel from handling slots of the object or its members
   413  by search panel from handling slots of the object or its members
       
   414  Scrolls view to state before connections
   381 */
   415 */
   382 void HsMenuView::disconnectSearchPanelSignals()
   416 void HsMenuView::disconnectSearchPanelSignals()
   383 {
   417 {
       
   418     disconnectSearchItemViewsSignals();
       
   419 
   384     disconnect(mBuilder.searchPanel(), SIGNAL(exitClicked()),
   420     disconnect(mBuilder.searchPanel(), SIGNAL(exitClicked()),
   385                this, SLOT(hideSearchPanel()));
   421                this, SLOT(hideSearchPanel()));
   386 
   422 
   387     disconnect(mBuilder.searchPanel(), SIGNAL(criteriaChanged(QString)),
   423     disconnect(mBuilder.searchPanel(), SIGNAL(criteriaChanged(QString)),
   388                &mMenuSearch, SLOT(findItem(QString)));
   424                this, SLOT(findItem(QString)));
   389 
   425 
   390     hideSearchPanelOnScrolling(false);
   426     searchFinished();
   391 }
   427     connectModelSignals();
   392 
   428     connectItemViewsSignals();
   393 /*!
       
   394   Connects or disconnects item views' (list) \a scrollingStarted
       
   395   signal with the object \a hideSearchPanel slot.
       
   396   \param hide When true connects the signals with the slots, otherwise
       
   397   disconnects them.
       
   398  */
       
   399 void HsMenuView::hideSearchPanelOnScrolling(bool hide)
       
   400 {
       
   401     const HbListView *const listView = mBuilder.listView();
       
   402 
       
   403     if (hide) {
       
   404         connect(listView, SIGNAL(scrollingStarted()),
       
   405                 this, SLOT(hideSearchPanel()));
       
   406     } else {
       
   407         disconnect(listView, SIGNAL(scrollingStarted()),
       
   408                    this, SLOT(hideSearchPanel()));
       
   409     }
       
   410 }
   429 }
   411 
   430 
   412 /*!
   431 /*!
   413  Groups All Application and All Collection actions. Connects Search Action with
   432  Groups All Application and All Collection actions. Connects Search Action with
   414  the object's \a showSearchPanel slot.
   433  the object's \a showSearchPanel slot.
   425             this, SLOT(showSearchPanel()));
   444             this, SLOT(showSearchPanel()));
   426 
   445 
   427     HSMENUTEST_FUNC_EXIT("HsMenuView::construct()");
   446     HSMENUTEST_FUNC_EXIT("HsMenuView::construct()");
   428 }
   447 }
   429 
   448 
       
   449 void HsMenuView::hideToolBar()
       
   450 {
       
   451     HSMENUTEST_FUNC_ENTRY("HsMenuView::hideToolBar()");
       
   452     mBuilder.view()->hideItems(Hb::ToolBarItem);
       
   453     HSMENUTEST_FUNC_EXIT("HsMenuView::hideToolBar()");
       
   454 }
       
   455 
       
   456 void HsMenuView::showToolBar()
       
   457 {
       
   458     HSMENUTEST_FUNC_ENTRY("HsMenuView::showToolBar()");
       
   459     mBuilder.view()->showItems(Hb::ToolBarItem);
       
   460     HSMENUTEST_FUNC_EXIT("HsMenuView::showToolBar()");
       
   461 }
       
   462 
   430 HsMenuMode HsMenuView::getHsMenuMode()
   463 HsMenuMode HsMenuView::getHsMenuMode()
   431 {
   464 {
   432     return mMenuMode;
   465     return mMenuMode;
   433 }
   466 }
   434 
   467 
   435 void HsMenuView::setHsMenuMode(HsMenuMode menuMode)
   468 void HsMenuView::setHsMenuMode(HsMenuMode menuMode)
   436 {
   469 {
   437     mMenuMode = menuMode;
   470     mMenuMode = menuMode;
   438 }
   471 }
       
   472 /*!
       
   473  Looks up for item and if found scrolls to it.
       
   474  \param criteriaStr The item name to find.
       
   475  */
       
   476 void HsMenuView::findItem(QString criteriaStr)
       
   477 {
       
   478     qDebug
       
   479         () << QString("hsmenuview::findItem: %1").arg(criteriaStr);
       
   480     HSMENUTEST_FUNC_ENTRY("hsmenuview::findItem");
       
   481 
       
   482     if ("" != criteriaStr) {
       
   483         mProxyModel->setFilterRegExp(QRegExp(criteriaStr,
       
   484             Qt::CaseInsensitive, QRegExp::FixedString));
       
   485     }
       
   486     else {
       
   487         mProxyModel->setFilterRegExp(QRegExp(QString(".*"),
       
   488             Qt::CaseInsensitive, QRegExp::RegExp));
       
   489         // scroll to first item in model
       
   490         mBuilder.listView()->scrollTo(
       
   491                 mProxyModel->mapFromSource(mModel->index(0)),
       
   492                 HbAbstractItemView::PositionAtTop);
       
   493     }
       
   494     HSMENUTEST_FUNC_EXIT("hsmenuview::findItem");
       
   495 }
       
   496 
       
   497 /*!
       
   498  Initializes search.
       
   499  */
       
   500 void HsMenuView::searchBegins()
       
   501 {
       
   502     HSMENUTEST_FUNC_ENTRY("hsmenuview::searchBegins");
       
   503     mProxyModel->invalidate();
       
   504     mProxyModel->setSourceModel(mModel);
       
   505     mProxyModel->setFilterRegExp(QRegExp(QString(".*"), Qt::CaseInsensitive,
       
   506         QRegExp::RegExp));
       
   507     setModelToView(mProxyModel);
       
   508     HSMENUTEST_FUNC_EXIT("hsmenuview::searchBegins");
       
   509 }
       
   510 
       
   511 /*!
       
   512  Ends search, scrolls view to last visible item in search view
       
   513  */
       
   514 void HsMenuView::searchFinished()
       
   515 {
       
   516     HSMENUTEST_FUNC_ENTRY("hsmenuview::searchFinished");
       
   517     QModelIndex temp = mProxyModel->mapToSource(mLastVisibleIndex);
       
   518     setModel(mModel);    
       
   519     mBuilder.listView()->scrollTo(temp, HbAbstractItemView::PositionAtTop);
       
   520     HSMENUTEST_FUNC_EXIT("hsmenuview::searchFinished");
       
   521 }
       
   522 
       
   523 /*!
       
   524  * Slot used to translate activated signal from proxy model to normal model
       
   525  */
       
   526 void HsMenuView::activatedProxySlot(const QModelIndex &index)
       
   527 {
       
   528     emit activated(mProxyModel->mapToSource(index));
       
   529 }
       
   530 
       
   531 /*!
       
   532  * Slot used to translate longPressed signal from proxy model to normal model
       
   533  */
       
   534 void HsMenuView::longPressedProxySlot(HbAbstractViewItem *item,
       
   535                                       const QPointF &coords)
       
   536 {
       
   537     /*
       
   538       this is a kind of hack, introduced for reasons:
       
   539       item object should be reusable later, but orbit (or qt) prevents setting
       
   540       its index model to previous state
       
   541       */
       
   542     mSearchIndex = mProxyModel->mapToSource(item->modelIndex());
       
   543     HbAbstractViewItem* itemNew = item->createItem();
       
   544     itemNew->setModelIndex(mSearchIndex);
       
   545     emit longPressed(itemNew, coords);
       
   546     delete itemNew;
       
   547 }
       
   548