--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videocollection/videocollectionview/src/videolistview.cpp Fri Apr 16 14:59:52 2010 +0300
@@ -0,0 +1,1494 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Videolist view class source code
+*
+*/
+
+#include <xqserviceutil.h>
+#include <QActionGroup>
+#include <hbinstance.h>
+#include <hbmainwindow.h>
+#include <hbmessagebox.h>
+#include <hbstackedwidget.h>
+#include <hbstackedlayout.h>
+#include <hblistwidget.h>
+#include <hbtoolbar.h>
+#include <hbaction.h>
+#include <hbmenu.h>
+#include <hbgroupbox.h>
+#include <hbpushbutton.h>
+#include <hbinputdialog.h>
+#include <vcxmyvideosdefs.h>
+
+#include "videoservices.h"
+#include "videolistselectiondialog.h"
+#include "videocollectionviewutils.h"
+#include "videolistwidget.h"
+#include "videohintwidget.h"
+#include "videolistview.h"
+#include "videocollectioncommon.h"
+#include "videocollectionwrapper.h"
+#include "videosortfilterproxymodel.h"
+#include "videocollectionuiloader.h"
+#include "mpxhbvideocommondefs.h"
+
+// remove these
+#include <QDebug>
+
+// ---------------------------------------------------------------------------
+// Constructor
+// ---------------------------------------------------------------------------
+//
+VideoListView::VideoListView(VideoCollectionUiLoader *uiLoader, QGraphicsItem *parent) :
+HbView(parent),
+mUiUtils(VideoCollectionViewUtils::instance()),
+mWrapper(VideoCollectionWrapper::instance()),
+mUiLoader(uiLoader),
+mIsService(false),
+mHintLoaded(false),
+mListsLoaded(false),
+mMultiselectionLoaded(false),
+mModelReady(false),
+mTransitionOngoing(false),
+mHintLevel(VideoHintWidget::AllVideos),
+mVideoServices(0),
+mCurrentList(0),
+mToolbarViewsActionGroup(0),
+mToolbarCollectionActionGroup(0)
+{
+ // NOP
+}
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+VideoListView::~VideoListView()
+{
+ qDebug() << "VideoListView::~VideoListView()";
+
+ toolBar()->clearActions();
+
+ mToolbarActions.clear();
+ mSortingRoles.clear();
+
+ if(mVideoServices)
+ {
+ mVideoServices->decreaseReferenceCount();
+ mVideoServices = 0;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// initializeView()
+// ---------------------------------------------------------------------------
+//
+int VideoListView::initializeView()
+{
+ if(!mUiLoader)
+ {
+ cleanup();
+ return -1;
+ }
+
+ if (XQServiceUtil::isService() && !mVideoServices)
+ {
+ mIsService = true;
+
+ mVideoServices = VideoServices::instance();
+
+ if (!mVideoServices)
+ {
+ cleanup();
+ return -1;
+ }
+ else
+ {
+ connect(mVideoServices, SIGNAL(titleReady(const QString&)), this, SLOT(titleReadySlot(const QString&)));
+ }
+ }
+
+ // start open all videos model
+ VideoSortFilterProxyModel *model =
+ mWrapper.getModel(VideoCollectionWrapper::EAllVideos);
+ if (model)
+ {
+ model->open(VideoCollectionCommon::ELevelVideos);
+ }
+ else
+ {
+ cleanup();
+ return -1;
+ }
+
+ // start loading widgets
+ QSet<QString> uiItems;
+ uiItems.insert(DOCML_NAME_VC_VIDEOLISTWIDGET);
+ uiItems.insert(DOCML_NAME_VC_HEADINGBANNER);
+ uiItems.insert(DOCML_NAME_OPTIONS_MENU);
+ if(!mIsService)
+ {
+ uiItems.insert(DOCML_NAME_ADD_TO_COLLECTION);
+ uiItems.insert(DOCML_NAME_CREATE_COLLECTION);
+ uiItems.insert(DOCML_NAME_DELETE_MULTIPLE);
+ }
+ uiItems.insert(DOCML_NAME_SORT_MENU);
+ uiItems.insert(DOCML_NAME_SORT_BY_DATE);
+ uiItems.insert(DOCML_NAME_SORT_BY_NAME);
+ uiItems.insert(DOCML_NAME_SORT_BY_NUMBER_OF_ITEMS);
+ uiItems.insert(DOCML_NAME_SORT_BY_RATING);
+ uiItems.insert(DOCML_NAME_SORT_BY_SIZE);
+ mUiLoader->startLoading(uiItems,
+ this,
+ SLOT(widgetReadySlot(QGraphicsWidget*, const QString&)),
+ SLOT(objectReadySlot(QObject*, const QString&)));
+ uiItems.clear();
+
+ // TODO: create toolbar temporarily here until it has been moved to docml
+ if (createToolbar() != 0)
+ {
+ cleanup();
+ return -1;
+ }
+
+ return 0;
+}
+
+// ---------------------------------------------------------------------------
+// titleReadySlot()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::titleReadySlot(const QString& title)
+{
+ setTitle(title);
+}
+
+// ---------------------------------------------------------------------------
+// activateView()
+// ---------------------------------------------------------------------------
+//
+int VideoListView::activateView()
+{
+ VideoListWidget *videoList =
+ mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_VIDEOLISTWIDGET);
+ if (videoList)
+ {
+ VideoCollectionCommon::TCollectionLevels level = VideoCollectionCommon::ELevelVideos;
+ if (mCurrentList)
+ {
+ level = mCurrentList->getLevel();
+ }
+ else
+ {
+ mCurrentList = videoList;
+ }
+
+ int result = mCurrentList->activate(level);
+ if(result < 0)
+ {
+ // activate failed, deactivate view so we get rid of dangling connections.
+ deactivateView();
+ return -1;
+ }
+
+ HbMainWindow *mainWnd = hbInstance->allMainWindows().value(0);
+ if (mainWnd)
+ {
+ mainWnd->setOrientation(Qt::Vertical, false);
+ if(!connect(
+ mainWnd, SIGNAL(aboutToChangeOrientation()),
+ this, SLOT( aboutToChangeOrientationSlot())) ||
+ !connect(
+ mainWnd, SIGNAL(orientationChanged(Qt::Orientation)),
+ this, SLOT(orientationChangedSlot(Qt::Orientation))) ||
+ !connect(
+ &mWrapper, SIGNAL(asyncStatus(int, QVariant&)),
+ this, SLOT(handleAsyncStatusSlot(int, QVariant&))) ||
+ !connect(
+ mCurrentList->getModel().sourceModel(), SIGNAL(modelChanged()),
+ this, SLOT(layoutChangedSlot())) ||
+ !connect(
+ mCurrentList->getModel().sourceModel(), SIGNAL(modelReady()),
+ this, SLOT(modelReadySlot())))
+ {
+ // deactivate view so we get rid of dangling connections.
+ deactivateView();
+ return -1;
+ }
+ }
+ else
+ {
+ return -1;
+ }
+ }
+ else
+ {
+ return -1;
+ }
+
+ return 0;
+}
+
+
+// ---------------------------------------------------------------------------
+// loadMultiSelection
+// ---------------------------------------------------------------------------
+//
+void VideoListView::loadMultiSelection()
+{
+ if(!mIsService)
+ {
+ if(!mMultiselectionLoaded)
+ {
+ QSet<QString> uiItems;
+ uiItems.insert(DOCML_NAME_DIALOG);
+ mUiLoader->startLoading(uiItems,
+ this,
+ SLOT(widgetReadySlot(QGraphicsWidget*, const QString&)),
+ SLOT(objectReadySlot(QObject*, const QString&)));
+ uiItems.clear();
+ mMultiselectionLoaded = true;
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// loadLists
+// ---------------------------------------------------------------------------
+//
+void VideoListView::loadLists(bool doAsync)
+{
+ if(!mListsLoaded)
+ {
+ QSet<QString> uiItems;
+ uiItems.insert(DOCML_NAME_VC_COLLECTIONWIDGET);
+ uiItems.insert(DOCML_NAME_VC_COLLECTIONCONTENTWIDGET);
+ mUiLoader->startLoading(uiItems,
+ this,
+ SLOT(widgetReadySlot(QGraphicsWidget*, const QString&)),
+ SLOT(objectReadySlot(QObject*, const QString&)));
+ uiItems.clear();
+
+ if(!doAsync)
+ {
+ VideoListWidget* widget(0);
+ widget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONWIDGET);
+ widget->setVisible(false);
+ widget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_COLLECTIONCONTENTWIDGET);
+ widget->setVisible(false);
+ }
+ mListsLoaded = true;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// doDelayedsSlot
+// ---------------------------------------------------------------------------
+//
+void VideoListView::doDelayedsSlot()
+{
+ loadLists(true);
+ loadMultiSelection();
+ loadHint(true);
+ emit doDelayeds();
+}
+
+// ---------------------------------------------------------------------------
+// modelReadySlot
+// ---------------------------------------------------------------------------
+//
+void VideoListView::modelReadySlot()
+{
+ mModelReady = true;
+
+ // since the reset signal arrives after
+ // layout changed, need to make sure that
+ // view is updated in case needed
+ layoutChangedSlot();
+}
+
+// ---------------------------------------------------------------------------
+// layoutChangedSlot
+// ---------------------------------------------------------------------------
+//
+void VideoListView::layoutChangedSlot()
+{
+ updateSubLabel();
+
+ if(mModelReady)
+ {
+ showHint();
+ }
+}
+
+// ---------------------------------------------------------------------------
+// deactivateView()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::deactivateView()
+{
+ HbMainWindow *mainWnd = hbInstance->allMainWindows().value(0);
+
+ mainWnd->unsetOrientation();
+
+ disconnect(mainWnd, SIGNAL(aboutToChangeOrientation()),
+ this, SLOT(aboutToChangeOrientationSlot()));
+
+ disconnect(mainWnd, SIGNAL(orientationChanged(Qt::Orientation)),
+ this, SLOT(orientationChangedSlot(Qt::Orientation)));
+
+ disconnect(&mWrapper, SIGNAL(asyncStatus(int, QVariant&)),
+ this, SLOT(handleAsyncStatusSlot(int, QVariant&)));
+
+ HbMenu *menu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);
+ if (menu)
+ {
+ menu->hide();
+ }
+
+ if(mCurrentList && &(mCurrentList->getModel()) && mCurrentList->getModel().sourceModel())
+ {
+ disconnect(mCurrentList->getModel().sourceModel(),
+ SIGNAL(modelChanged()),
+ this, SLOT(layoutChangedSlot()));
+ disconnect(mCurrentList->getModel().sourceModel(),
+ SIGNAL(modelReady()),
+ this, SLOT(modelReadySlot()));
+
+ showHint(false);
+ }
+
+ if(mCurrentList)
+ {
+ mCurrentList->deactivate();
+ }
+}
+
+// ---------------------------------------------------------------------------
+// back()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::back()
+{
+ // NOP
+}
+
+// ---------------------------------------------------------------------------
+// cleanup()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::cleanup()
+{
+ delete mToolbarViewsActionGroup;
+ mToolbarViewsActionGroup = 0;
+
+ delete mToolbarCollectionActionGroup;
+ mToolbarCollectionActionGroup = 0;
+
+ mCurrentList = 0;
+}
+
+// ---------------------------------------------------------------------------
+// createToolbar()
+// Creates toolbar, toolbar actions and toolbar icons
+// ---------------------------------------------------------------------------
+//
+int VideoListView::createToolbar()
+{
+ // Create actiongroup and add all actions to it. This ensures that only one is
+ // active at certain moment.
+
+ if(!mToolbarViewsActionGroup && !mToolbarCollectionActionGroup)
+ {
+ mToolbarViewsActionGroup = new QActionGroup(this);
+ mToolbarCollectionActionGroup = new QActionGroup(this);
+
+ if(!mToolbarViewsActionGroup || !mToolbarCollectionActionGroup)
+ {
+ delete mToolbarViewsActionGroup;
+ mToolbarViewsActionGroup = 0;
+
+ delete mToolbarCollectionActionGroup;
+ mToolbarCollectionActionGroup = 0;
+
+ return -1;
+ }
+
+ // create toolbar item actions
+
+ // All Videos tab
+ mToolbarActions[ETBActionAllVideos] = createAction(":/images/qtg_mono_video_all.svg",
+ mToolbarViewsActionGroup, SLOT(openAllVideosViewSlot()));
+
+ // Collections tab
+ mToolbarActions[ETBActionCollections] = createAction("qtg_mono_video_collection",
+ mToolbarViewsActionGroup, SLOT(openCollectionViewSlot()));
+
+ if (!mIsService)
+ {
+ // Services tab
+ mToolbarActions[ETBActionServices] = createAction("qtg_mono_ovistore",
+ mToolbarViewsActionGroup, SLOT(openServicesViewSlot()));
+ // Add Videos tab
+ mToolbarActions[ETBActionAddVideos] =
+ createAction("qtg_mono_add_to_video_collection",
+ mToolbarCollectionActionGroup, SLOT(addVideosToCollectionSlot()));
+
+ // Remove Videos tab
+ mToolbarActions[ETBActionRemoveVideos] =
+ createAction(":/images/qtg_mono_remove_from_video_collection.svg",
+ mToolbarCollectionActionGroup, SLOT(removeVideosFromCollectionSlot()));
+ }
+
+ HbToolBar *bar = toolBar(); // First call to toolBar() creates the object, so on failure it could return 0.
+
+ if( !bar
+ || !mToolbarActions[ETBActionAllVideos]
+ || !mToolbarActions[ETBActionCollections]
+ || (!mToolbarActions[ETBActionServices] && !mIsService)
+ || (!mToolbarActions[ETBActionAddVideos] && !mIsService)
+ || (!mToolbarActions[ETBActionRemoveVideos] && !mIsService))
+ {
+ delete mToolbarActions[ETBActionAllVideos];
+ delete mToolbarActions[ETBActionCollections];
+ delete mToolbarActions[ETBActionServices];
+ delete mToolbarActions[ETBActionAddVideos];
+ delete mToolbarActions[ETBActionRemoveVideos];
+ return -1;
+ }
+
+ // Collection view actions are not checkable
+ mToolbarActions[ETBActionAllVideos]->setCheckable(true);
+ mToolbarActions[ETBActionCollections]->setCheckable(true);
+
+ if (!mIsService)
+ {
+ mToolbarActions[ETBActionServices]->setCheckable(false);
+ }
+
+ // Allvideos is checked at creation phase
+ mToolbarActions[ETBActionAllVideos]->setChecked(true);
+
+ bar->addActions(mToolbarViewsActionGroup->actions());
+ bar->setVisible(true);
+ }
+
+ return 0;
+}
+
+// ---------------------------------------------------------------------------
+// createAction()
+// ---------------------------------------------------------------------------
+//
+HbAction* VideoListView::createAction(QString icon,
+ QActionGroup* actionGroup, const char *slot)
+{
+ HbAction* action = new HbAction(actionGroup);
+ if(!action) {
+ return 0;
+ }
+
+ HbIcon hbIcon(icon);
+ action->setIcon(hbIcon);
+
+ if(!connect(action, SIGNAL(triggered()), this, slot)) {
+ // actiongroup deletion deletes this also.
+ // return 0 tells that there was a problem in creation to caller.
+ delete action;
+ return 0;
+ }
+
+ return action;
+}
+
+// ---------------------------------------------------------------------------
+// loadHint
+// ---------------------------------------------------------------------------
+//
+void VideoListView::loadHint(bool doAsync)
+{
+ if(!mHintLoaded)
+ {
+ QSet<QString> uiItems;
+ uiItems.insert(DOCML_NAME_VC_VIDEOHINTWIDGET);
+ uiItems.insert(DOCML_NAME_HINT_BUTTON);
+ uiItems.insert(DOCML_NAME_NO_VIDEOS_LABEL);
+ mUiLoader->startLoading(uiItems,
+ this,
+ SLOT(widgetReadySlot(QGraphicsWidget*, const QString&)),
+ SLOT(objectReadySlot(QObject*, const QString&)));
+ uiItems.clear();
+
+ if(!doAsync)
+ {
+ HbPushButton* button = mUiLoader->findWidget<HbPushButton>(DOCML_NAME_HINT_BUTTON);
+ }
+ mHintLoaded = true;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// showHint
+// ---------------------------------------------------------------------------
+//
+void VideoListView::showHint(bool show)
+{
+ if(!mCurrentList)
+ {
+ return;
+ }
+
+ VideoSortFilterProxyModel &model = mCurrentList->getModel();
+
+ HbGroupBox *subLabel =
+ mUiLoader->findWidget<HbGroupBox>(DOCML_NAME_VC_HEADINGBANNER);
+
+ if((!mHintLoaded && !show) || (!mHintLoaded && model.rowCount() != 0))
+ {
+ if(subLabel)
+ {
+ subLabel->show();
+ }
+ return;
+ }
+ else if(!mHintLoaded)
+ {
+ loadHint(false);
+ }
+
+ VideoHintWidget *hintWidget =
+ mUiLoader->findWidget<VideoHintWidget>(
+ DOCML_NAME_VC_VIDEOHINTWIDGET);
+
+ if (hintWidget)
+ {
+ hintWidget->setLevel(mHintLevel);
+ }
+
+ if (mModelReady &&
+ model.rowCount() == 0 &&
+ hintWidget)
+ {
+ show ? hintWidget->activate() : hintWidget->deactivate();
+ }
+ else if (hintWidget)
+ {
+ show = false;
+ hintWidget->deactivate();
+ }
+
+ if(show && mToolbarViewsActionGroup && mToolbarCollectionActionGroup)
+ {
+ if(!mIsService)
+ {
+ mToolbarActions[ETBActionRemoveVideos]->setVisible(false);
+ }
+ if(mCurrentList->getLevel() == VideoCollectionCommon::ELevelDefaultColl)
+ {
+ if(!mIsService)
+ {
+ mToolbarActions[ETBActionAddVideos]->setVisible(false);
+ }
+ hintWidget->setButtonShown(false);
+ }
+ else
+ {
+ hintWidget->setButtonShown(true);
+ }
+ }
+ else if(mToolbarViewsActionGroup && mToolbarCollectionActionGroup)
+ {
+ if(!mIsService)
+ {
+ if(mToolbarActions[ETBActionRemoveVideos]->isVisible() == false)
+ {
+ mToolbarActions[ETBActionRemoveVideos]->setVisible(true);
+ }
+ if(mToolbarActions[ETBActionAddVideos]->isVisible() == false)
+ {
+ mToolbarActions[ETBActionAddVideos]->setVisible(true);
+ }
+ }
+ hintWidget->setButtonShown(true);
+ }
+
+ if (subLabel)
+ {
+ if (show &&
+ subLabel->isVisible() &&
+ mCurrentList->getLevel() == VideoCollectionCommon::ELevelVideos)
+ {
+ subLabel->hide();
+ }
+ else if (!subLabel->isVisible())
+ {
+ subLabel->show();
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// setHintLevel
+// ---------------------------------------------------------------------------
+//
+void VideoListView::setHintLevel(VideoHintWidget::HintLevel level)
+{
+ mHintLevel = level;
+}
+
+// ---------------------------------------------------------------------------
+// updateSubLabel
+// ---------------------------------------------------------------------------
+//
+void VideoListView::updateSubLabel()
+{
+ VideoSortFilterProxyModel *model = 0;
+ if(mCurrentList)
+ {
+ model = &mCurrentList->getModel();
+ }
+
+ if (model)
+ {
+ int itemCount = model->rowCount();
+ VideoListWidget *videoListWidget =
+ mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_VIDEOLISTWIDGET);
+
+ VideoListWidget *collectionWidget =
+ mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_COLLECTIONWIDGET);
+
+ VideoListWidget *collectionContentWidget =
+ mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_COLLECTIONCONTENTWIDGET);
+
+ HbGroupBox *subLabel =
+ mUiLoader->findWidget<HbGroupBox>(
+ DOCML_NAME_VC_HEADINGBANNER);
+
+ if(subLabel)
+ {
+ if (mCurrentList == videoListWidget)
+ {
+ subLabel->setHeading(hbTrId("txt_videos_subtitle_ln_videos", itemCount));
+ }
+ else if (mCurrentList == collectionWidget)
+ {
+ subLabel->setHeading(hbTrId("txt_videos_subtitle_ln_collections", itemCount));
+ }
+ else if(mCurrentList == collectionContentWidget)
+ {
+ subLabel->setHeading(hbTrId("txt_videos_subtitle_1_l2").arg(mCollectionName).arg(itemCount));
+ }
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// showAction()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::showAction(bool show, const QString &name)
+{
+ HbAction *action = mUiLoader->findObject<HbAction>(name);
+ if (!action)
+ {
+ // must be menu widget
+ HbMenu *menu = mUiLoader->findWidget<HbMenu>(name);
+ if (menu)
+ {
+ action = menu->menuAction();
+ }
+ }
+
+ // hide or show action
+ if (action)
+ {
+ action->setVisible(show);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// isActionChecked()
+// ---------------------------------------------------------------------------
+//
+bool VideoListView::isActionChecked(const QString &name)
+{
+ bool isChecked = false;
+
+ HbAction *action = mUiLoader->findObject<HbAction>(name);
+ if (!action)
+ {
+ // must be menu widget
+ HbMenu *menu = mUiLoader->findWidget<HbMenu>(name);
+ if (menu)
+ {
+ action = menu->menuAction();
+ }
+ }
+
+ // check if action is checked
+ if (action)
+ {
+ isChecked = action->isChecked();
+ }
+
+ return isChecked;
+}
+
+// ---------------------------------------------------------------------------
+// isActionChecked()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::setActionChecked(bool setChecked, const QString &name)
+{
+ HbAction *action = mUiLoader->findObject<HbAction>(name);
+ if (!action)
+ {
+ // must be menu widget
+ HbMenu *menu = mUiLoader->findWidget<HbMenu>(name);
+ if (menu)
+ {
+ action = menu->menuAction();
+ }
+ }
+
+ // update action check state
+ if (action)
+ {
+ action->setChecked(setChecked);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// openAllVideosViewSlot()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::openAllVideosViewSlot()
+{
+ if(!mListsLoaded)
+ {
+ loadLists(false);
+ }
+
+ VideoListWidget *videoListWidget =
+ mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_VIDEOLISTWIDGET);
+
+ if (mCurrentList &&
+ videoListWidget &&
+ mCurrentList != videoListWidget)
+ {
+ // deactivate old list
+ mCurrentList->deactivate();
+
+ // activate all videos list
+ mCurrentList = videoListWidget;
+ mCurrentList->activate(VideoCollectionCommon::ELevelVideos);
+
+ // since collection is not to be opened at this point,
+ // we do not receive lauoutChanged for updating the hind -widget
+ // if needed, need to show it here is needed
+ setHintLevel(VideoHintWidget::AllVideos);
+ showHint();
+ }
+}
+
+// ---------------------------------------------------------------------------
+// openCollectionViewSlot()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::openCollectionViewSlot()
+{
+ if(!mListsLoaded)
+ {
+ loadLists(false);
+ }
+
+ VideoListWidget *collectionWidget =
+ mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_COLLECTIONWIDGET);
+
+ if (mCurrentList &&
+ mCurrentList != collectionWidget)
+ {
+ // deactivate all videos widget
+ mCurrentList->deactivate();
+
+ // activate video collection widget
+ mCurrentList = collectionWidget;
+ mCurrentList->activate(VideoCollectionCommon::ELevelCategory);
+
+ VideoSortFilterProxyModel &model = mCurrentList->getModel();
+ VideoCollectionViewUtils::sortModel(&model, false);
+
+ // the collection view is not empty, so we can hide the hint in advance.
+ showHint(false);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// openNewAlbumSlot()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::openNewAlbumSlot(const QModelIndex &parent,
+ int start,
+ int end)
+{
+ Q_UNUSED(end);
+ if(!mCurrentList)
+ {
+ return;
+ }
+ // invalidate model
+ VideoSortFilterProxyModel &model = mCurrentList->getModel();
+ model.invalidate();
+
+ // activate new index
+ QModelIndex index = model.index(start, 0, parent);
+ if (index.isValid())
+ {
+ // disconnect rowsInserted signal to prevent obsolete slot calls
+ disconnect( &model, SIGNAL(rowsInserted(const QModelIndex&, int, int)),
+ this, SLOT(openNewAlbumSlot(const QModelIndex&, int, int)));
+
+ mCurrentList->emitActivated(index);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// openservicesViewSlot()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::openServicesViewSlot()
+{
+ debugNotImplementedYet();
+}
+
+// ---------------------------------------------------------------------------
+// startSorting()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::startSorting()
+{
+ HbMenu *optionsMenu =
+ mUiLoader->findWidget<HbMenu>(
+ DOCML_NAME_OPTIONS_MENU);
+ if (optionsMenu)
+ {
+ // get sorting role from active action
+ HbAction *action = optionsMenu->activeAction()->menu()->activeAction();
+ if(action)
+ {
+ doSorting(mSortingRoles[action]);
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// doSorting()
+// ---------------------------------------------------------------------------
+//
+void VideoListView::doSorting(int role)
+{
+ // sort model
+ Qt::SortOrder order(Qt::AscendingOrder);
+ VideoSortFilterProxyModel &model = mCurrentList->getModel();
+ if(model.sortRole() == role && model.sortOrder() == Qt::AscendingOrder)
+ {
+ order = Qt::DescendingOrder;
+ }
+ model.doSorting(role, order);
+
+ // save sorting values
+ mUiUtils.saveSortingValues(role, order);
+}
+
+// -------------------------------------------------------------------------------------------------
+// aboutToChangeOrientationSlot()
+// hide all items in the window during orientation change
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::aboutToChangeOrientationSlot()
+{
+ // this method is required for changing from to mediawall
+}
+
+// -------------------------------------------------------------------------------------------------
+// orientationChangedSlot()
+// orientation changed, items can be put back to visible after view has handled the change
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::orientationChangedSlot( Qt::Orientation orientation )
+{
+ // this method is required for changing from to mediawall
+
+ // in landscape we need to hide the title and the toolbar. (also required for the mediawall?)
+ // TODO: how about the feature where the toolbar comes visible if screen is tapped?
+ this->setItemVisible(Hb::AllItems, orientation == Qt::Vertical);
+}
+
+// -------------------------------------------------------------------------------------------------
+// deleteItemsSlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::deleteItemsSlot()
+{
+ if(!mCurrentList)
+ {
+ return;
+ }
+
+ if(!mMultiselectionLoaded)
+ {
+ loadMultiSelection();
+ }
+
+ VideoListSelectionDialog *dialog =
+ mUiLoader->findWidget<VideoListSelectionDialog>(
+ DOCML_NAME_DIALOG);
+ if (dialog)
+ {
+ TMPXItemId collectionId = mCurrentList->getModel().getOpenItem();
+ dialog->setupContent(VideoListSelectionDialog::EDeleteVideos, collectionId);
+ dialog->exec();
+ }
+}
+
+// -------------------------------------------------------------------------------------------------
+// createCollectionSlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::createCollectionSlot()
+{
+ if(!mCurrentList)
+ {
+ return;
+ }
+
+ VideoSortFilterProxyModel &model = mCurrentList->getModel();
+
+
+ bool ok = false;
+ // query a name for the collection
+ QString label(hbTrId("txt_videos_title_enter_name"));
+ QString text(hbTrId("txt_videos_dialog_entry_new_collection"));
+ text = HbInputDialog::getText(label, text, &ok);
+ if (ok && text.length())
+ {
+ // resolve collection true name and add new album
+ text = model.resolveAlbumName(text);
+
+ // when collection reports about new collection, we open it right away,
+ // for that, connect to rowsInserted so that the new album can be opened
+ if(!connect(&model, SIGNAL(rowsInserted(const QModelIndex&, int, int)),
+ this, SLOT(openNewAlbumSlot(const QModelIndex&, int, int))))
+ {
+ return;
+ }
+
+ model.addNewAlbum(text);
+ }
+}
+
+// -------------------------------------------------------------------------------------------------
+// addVideosToCollectionSlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::addVideosToCollectionSlot()
+{
+ if(!mCurrentList)
+ {
+ return;
+ }
+
+ if(!mMultiselectionLoaded)
+ {
+ loadMultiSelection();
+ }
+
+ VideoListSelectionDialog *dialog =
+ mUiLoader->findWidget<VideoListSelectionDialog>(
+ DOCML_NAME_DIALOG);
+ if (!dialog)
+ {
+ // fatal: no selection dialog
+ return;
+ }
+ if(mCurrentList->getLevel() == VideoCollectionCommon::ELevelAlbum)
+ {
+ // album is opened, do not proceed in case it already have same amount
+ // of videos than all videos view.
+ VideoListWidget *allVideos = mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_VIDEOLISTWIDGET);
+ if(allVideos)
+ {
+ int count = allVideos->getModel().rowCount();
+ if(count == mCurrentList->getModel().rowCount())
+ {
+ if(count)
+ {
+ QVariant emptyAdditional;
+ mUiUtils.showStatusMsgSlot(
+ VideoCollectionCommon::statusAllVideosAlreadyInCollection,
+ emptyAdditional);
+ }
+ return;
+ }
+ }
+ }
+ TMPXItemId collectionId = mCurrentList->getModel().getOpenItem();
+ dialog->setupContent(VideoListSelectionDialog::EAddToCollection, collectionId);
+ dialog->exec();
+}
+
+// -------------------------------------------------------------------------------------------------
+// removeVideosFromCollectionSlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::removeVideosFromCollectionSlot()
+{
+ if(!mCurrentList)
+ {
+ return;
+ }
+ // not allowed if for some reason current widget
+ // is all videos or collection or there are no items
+ if(mCurrentList->getLevel() < VideoCollectionCommon::ELevelDefaultColl ||
+ !mCurrentList->getModel().rowCount())
+ {
+ return;
+ }
+
+ if(!mMultiselectionLoaded)
+ {
+ loadMultiSelection();
+ }
+
+ VideoListSelectionDialog *dialog =
+ mUiLoader->findWidget<VideoListSelectionDialog>(
+ DOCML_NAME_DIALOG);
+ if (!dialog)
+ {
+ // fatal: no selection dialog
+ return;
+ }
+ TMPXItemId collectionId = mCurrentList->getModel().getOpenItem();
+ if(collectionId != TMPXItemId::InvalidId() && collectionId.iId2 != KVcxMvcMediaTypeVideo)
+ {
+ dialog->setupContent(VideoListSelectionDialog::ERemoveFromCollection, collectionId);
+ dialog->exec();
+ }
+}
+
+// -------------------------------------------------------------------------------------------------
+// aboutToShowMainMenuSlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::aboutToShowMainMenuSlot()
+{
+ if (!mCurrentList ||
+ !mToolbarViewsActionGroup ||
+ !mToolbarCollectionActionGroup)
+ {
+ return;
+ }
+
+ // hide all actions by default
+ showAction(false, DOCML_NAME_ADD_TO_COLLECTION);
+ showAction(false, DOCML_NAME_CREATE_COLLECTION);
+ showAction(false, DOCML_NAME_DELETE_MULTIPLE);
+ showAction(false, DOCML_NAME_SORT_BY_DATE);
+ showAction(false, DOCML_NAME_SORT_BY_NAME);
+ showAction(false, DOCML_NAME_SORT_BY_NUMBER_OF_ITEMS);
+ showAction(false, DOCML_NAME_SORT_BY_RATING);
+ showAction(false, DOCML_NAME_SORT_BY_SIZE);
+ showAction(false, DOCML_NAME_SORT_MENU);
+
+ VideoSortFilterProxyModel &model = mCurrentList->getModel();
+ if (!model.rowCount(QModelIndex()))
+ {
+ return;
+ }
+
+ // get current sorting values
+ int role;
+ Qt::SortOrder order;
+ model.getSorting(role, order);
+
+ HbAction *firstAction = (HbAction*)(toolBar()->actions().first());
+
+ if(mToolbarViewsActionGroup->checkedAction() == mToolbarActions[ETBActionAllVideos] &&
+ firstAction == mToolbarActions[ETBActionAllVideos])
+ {
+ showAction(true, DOCML_NAME_SORT_MENU);
+ showAction(true, DOCML_NAME_SORT_BY_DATE);
+ if (isActionChecked(DOCML_NAME_SORT_BY_NUMBER_OF_ITEMS))
+ {
+ //TODO: when changing between videos and categories, sorting order needs to be changed, if new
+ // view does not have the previously active sorting order supported
+ showAction(true, DOCML_NAME_SORT_BY_DATE);
+ }
+ else
+ {
+ HbAction* action = mSortingRoles.key(role);
+ if (action)
+ {
+ action->setChecked(true);
+ }
+ }
+
+ showAction(true, DOCML_NAME_SORT_BY_NAME);
+ showAction(true, DOCML_NAME_SORT_BY_SIZE);
+
+ if (!mIsService)
+ {
+ showAction(true, DOCML_NAME_ADD_TO_COLLECTION);
+ showAction(true, DOCML_NAME_DELETE_MULTIPLE);
+ }
+ }
+ else if(mToolbarViewsActionGroup->checkedAction() == mToolbarActions[ETBActionCollections] &&
+ firstAction == mToolbarActions[ETBActionAllVideos] )
+ {
+ if (!mIsService)
+ {
+ showAction(true, DOCML_NAME_CREATE_COLLECTION);
+ }
+ showAction(true, DOCML_NAME_SORT_MENU);
+ showAction(true, DOCML_NAME_SORT_BY_NAME);
+
+ if (isActionChecked(DOCML_NAME_SORT_BY_DATE) ||
+ isActionChecked(DOCML_NAME_SORT_BY_SIZE))
+ {
+ //TODO: when changing between videos and categories, sorting order needs to be changed, if new
+ // view does not have the previously active sorting order supported
+ setActionChecked(true, DOCML_NAME_SORT_BY_NAME);
+ }
+ else
+ {
+ HbAction* action = mSortingRoles.key(role);
+ if (action)
+ {
+ action->setChecked(true);
+ }
+ }
+
+ showAction(true, DOCML_NAME_SORT_BY_NUMBER_OF_ITEMS);
+ }
+ else if(firstAction != mToolbarActions[ETBActionAllVideos])
+ {
+ showAction(true, DOCML_NAME_SORT_MENU);
+ showAction(true, DOCML_NAME_SORT_BY_DATE);
+ if (isActionChecked(DOCML_NAME_SORT_BY_NUMBER_OF_ITEMS))
+ {
+ //TODO: when changing between videos and categories, sorting order needs to be changed, if new
+ // view does not have the previously active sorting order supported
+ showAction(true, DOCML_NAME_SORT_BY_DATE);
+ }
+ else
+ {
+ HbAction* action = mSortingRoles.key(role);
+ if (action)
+ {
+ action->setChecked(true);
+ }
+ }
+
+ showAction(true, DOCML_NAME_SORT_BY_NAME);
+ showAction(true, DOCML_NAME_SORT_BY_SIZE);
+
+ if (!mIsService)
+ {
+ showAction(true, DOCML_NAME_DELETE_MULTIPLE);
+ }
+ }
+}
+
+// -------------------------------------------------------------------------------------------------
+// handleAsyncStatusSlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::handleAsyncStatusSlot(int statusCode, QVariant &additional)
+{
+ // show msg from status
+ mUiUtils.showStatusMsgSlot(statusCode, additional);
+}
+
+// -------------------------------------------------------------------------------------------------
+// collectionOpenedSlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::collectionOpenedSlot(bool collectionOpened,
+ const QString& collection,
+ const QModelIndex &index)
+{
+ if(mTransitionOngoing)
+ {
+ return;
+ }
+ else
+ {
+ // clear toolbar actions.
+ toolBar()->clearActions();
+ }
+
+ // update collection specific information
+ mCollectionName = collection;
+
+ if(collectionOpened)
+ {
+ if(!index.isValid())
+ {
+ return;
+ }
+
+ // open album view
+ VideoListWidget *collectionContentWidget =
+ mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_COLLECTIONCONTENTWIDGET);
+
+ if (mCurrentList &&
+ mCurrentList != collectionContentWidget)
+ {
+ // get item id before deactivating
+ TMPXItemId itemId = TMPXItemId::InvalidId();
+ itemId = mCurrentList->getModel().getMediaIdAtIndex(index);
+
+ // only category or album can be activated here
+ if(itemId == TMPXItemId::InvalidId() ||
+ (itemId.iId2 != KVcxMvcMediaTypeCategory &&
+ itemId.iId2 != KVcxMvcMediaTypeAlbum))
+ {
+ return;
+ }
+
+ // Send level that is opened with the effect.
+ QVariant nextLevel;
+ if(itemId.iId2 == KVcxMvcMediaTypeCategory)
+ {
+ nextLevel = QVariant(VideoCollectionCommon::ELevelDefaultColl);
+ }
+ else if(itemId.iId2 == KVcxMvcMediaTypeAlbum)
+ {
+ nextLevel = QVariant(VideoCollectionCommon::ELevelAlbum);
+ }
+
+ // Start fetching content.
+ collectionContentWidget->getModel().openItem(itemId);
+
+ HbEffect::start(collectionContentWidget,
+ EFFECT_SLIDE_IN_TO_LEFT,
+ this,
+ "finishCollectionOpenedSlot",
+ nextLevel);
+
+ mTransitionOngoing = true;
+ }
+ }
+ else
+ {
+ // open categories view.
+ VideoListWidget *collectionContentWidget =
+ mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_COLLECTIONCONTENTWIDGET);
+
+ HbEffect::start(collectionContentWidget,
+ EFFECT_SLIDE_OUT_TO_LEFT,
+ this,
+ "finishCollectionClosedSlot");
+
+ mTransitionOngoing = true;
+ }
+}
+
+// -------------------------------------------------------------------------------------------------
+// finishCollectionOpenedSlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::finishCollectionOpenedSlot(const HbEffect::EffectStatus &status)
+{
+ Q_UNUSED(status);
+
+ mTransitionOngoing = false;
+
+ // deactivat current widget.
+ mCurrentList->deactivate();
+
+ // activate video collection content widget.
+ mCurrentList = mUiLoader->findWidget<VideoListWidget>(
+ DOCML_NAME_VC_COLLECTIONCONTENTWIDGET);
+
+ if(!mCurrentList || !status.userData.isValid())
+ {
+ return;
+ }
+
+ updateSubLabel();
+
+ VideoCollectionCommon::TCollectionLevels level =
+ static_cast<VideoCollectionCommon::TCollectionLevels>(status.userData.toInt());
+ mCurrentList->activate(level);
+
+ // update hint widget
+ setHintLevel(VideoHintWidget::Collection);
+ showHint();
+
+ // update toolbar for albums, default categories don't have one.
+ if(level == VideoCollectionCommon::ELevelAlbum &&
+ mToolbarCollectionActionGroup && mToolbarActions.contains(ETBActionCollections))
+ {
+ mToolbarActions[ETBActionCollections]->setChecked(false);
+ toolBar()->addActions(mToolbarCollectionActionGroup->actions());
+ }
+}
+
+// -------------------------------------------------------------------------------------------------
+// finishCollectionClosedSlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::finishCollectionClosedSlot(const HbEffect::EffectStatus &status)
+{
+ Q_UNUSED(status);
+
+ mTransitionOngoing = false;
+
+ // open collection view
+ openCollectionViewSlot();
+
+ // update toolbar
+ if(mToolbarViewsActionGroup && mToolbarActions.contains(ETBActionCollections))
+ {
+ toolBar()->addActions(mToolbarViewsActionGroup->actions());
+ mToolbarActions[ETBActionCollections]->setChecked(true);
+ }
+}
+
+// -------------------------------------------------------------------------------------------------
+// widgetReadySlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::widgetReadySlot(QGraphicsWidget *widget, const QString &name)
+{
+ if (name.compare(DOCML_NAME_VC_VIDEOLISTWIDGET) == 0)
+ {
+ connect(widget, SIGNAL(command(int)), this, SIGNAL(command(int)));
+ connect(this, SIGNAL(doDelayeds()), widget, SLOT(doDelayedsSlot()));
+ }
+ else if (name.compare(DOCML_NAME_VC_COLLECTIONWIDGET) == 0)
+ {
+ connect(
+ widget, SIGNAL(collectionOpened(bool, const QString&, const QModelIndex&)),
+ this, SLOT(collectionOpenedSlot(bool, const QString&, const QModelIndex&)));
+ connect(this, SIGNAL(doDelayeds()), widget, SLOT(doDelayedsSlot()));
+ emit(doDelayeds());
+ }
+ else if (name.compare(DOCML_NAME_VC_COLLECTIONCONTENTWIDGET) == 0)
+ {
+ connect(widget, SIGNAL(command(int)), this, SIGNAL(command(int)));
+ connect(
+ widget, SIGNAL(collectionOpened(bool, const QString&, const QModelIndex&)),
+ this, SLOT(collectionOpenedSlot(bool, const QString&, const QModelIndex&)));
+ connect(this, SIGNAL(doDelayeds()), widget, SLOT(doDelayedsSlot()));
+ emit(doDelayeds());
+ }
+ else if (name.compare(DOCML_NAME_OPTIONS_MENU) == 0)
+ {
+ connect(
+ widget, SIGNAL(aboutToShow()), this, SLOT(aboutToShowMainMenuSlot()));
+ }
+ else if (name.compare(DOCML_NAME_HINT_BUTTON) == 0)
+ {
+ connect(widget, SIGNAL(clicked(bool)), this, SLOT(openServicesViewSlot()));
+ }
+}
+
+// -------------------------------------------------------------------------------------------------
+// objectReadySlot
+// -------------------------------------------------------------------------------------------------
+//
+void VideoListView::objectReadySlot(QObject *object, const QString &name)
+{
+ if (name.compare(DOCML_NAME_SORT_BY_DATE) == 0)
+ {
+ HbAction *action = qobject_cast<HbAction*>(object);
+ if (action)
+ {
+ connect(action, SIGNAL(triggered()), this, SLOT(startSorting()));
+ mSortingRoles[action] = VideoCollectionCommon::KeyDateTime;
+ }
+ }
+ else if (name.compare(DOCML_NAME_SORT_BY_NAME) == 0)
+ {
+ HbAction *action = qobject_cast<HbAction*>(object);
+ if (action)
+ {
+ connect(action, SIGNAL(triggered()), this, SLOT(startSorting()));
+ mSortingRoles[action] = Qt::DisplayRole;
+ }
+ }
+ else if (name.compare(DOCML_NAME_SORT_BY_NUMBER_OF_ITEMS) == 0)
+ {
+ HbAction *action = qobject_cast<HbAction*>(object);
+ if (action)
+ {
+ // TODO: implement
+ connect(action, SIGNAL(triggered()), this, SLOT(debugNotImplementedYet()));
+ mSortingRoles[action] = 0;
+ }
+ }
+ else if (name.compare(DOCML_NAME_SORT_BY_SIZE) == 0)
+ {
+ HbAction *action = qobject_cast<HbAction*>(object);
+ if (action)
+ {
+ connect(action, SIGNAL(triggered()), this, SLOT(startSorting()));
+ mSortingRoles[action] = VideoCollectionCommon::KeySizeValue;
+ }
+ }
+ else if (name.compare(DOCML_NAME_ADD_TO_COLLECTION) == 0)
+ {
+ HbAction *action = qobject_cast<HbAction*>(object);
+ if (action)
+ {
+ connect(action, SIGNAL(triggered()), this, SLOT(addVideosToCollectionSlot()));
+ }
+ }
+ else if (name.compare(DOCML_NAME_CREATE_COLLECTION) == 0)
+ {
+ HbAction *action = qobject_cast<HbAction*>(object);
+ if (action)
+ {
+ connect(action, SIGNAL(triggered()), this, SLOT(createCollectionSlot()));
+ }
+ }
+ else if (name.compare(DOCML_NAME_DELETE_MULTIPLE) == 0)
+ {
+ HbAction *action = qobject_cast<HbAction*>(object);
+ if (action)
+ {
+ connect(action, SIGNAL(triggered()), this, SLOT(deleteItemsSlot()));
+ }
+ }
+}
+
+// Just for testing, remove this
+void VideoListView::debugNotImplementedYet()
+{
+ HbMessageBox::information(tr("Not implemented yet"));
+}
+
+// end of file
+