/*
* 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: VideoListToolbar class source code
*
*/
// Version : %version: 1.1.2 %
// INCLUDE FILES
#include <qactiongroup.h>
#include <hbaction.h>
#include <hbtoolbarextension.h>
#include <vcxmyvideosdefs.h>
#include "videolisttoolbar.h"
#include "videoservices.h"
#include "videooperatorservice.h"
#include "videocollectioncenrepdefs.h"
#include "videocollectiontrace.h"
#include "videolistview.h"
#include "videocollectionuiloader.h"
#include "videolistwidget.h"
#include "videoproxymodelgeneric.h"
#include "videolistselectiondialog.h"
// Object names.
const char* const LIST_VIEW_OBJECT_NAME_TOOLBAR_EXTENSION = "vc::ListViewToolbarExtension";
// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
VideoListToolbar::VideoListToolbar(VideoCollectionUiLoader* uiLoader, VideoListView* parent)
: QObject(parent)
, mCurrentLevel(VideoCollectionCommon::ELevelInvalid)
, mUiUtils(VideoCollectionViewUtils::instance())
, mUiLoader(uiLoader)
, mListView(parent)
, mVideoServices(0)
, mToolbarViewsActionGroup(0)
, mToolbarCollectionActionGroup(0)
, mToolbarServiceExtension(0)
{
FUNC_LOG;
}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
VideoListToolbar::~VideoListToolbar()
{
FUNC_LOG;
emit actionsChanged(mViewStateActions[VideoCollectionCommon::ELevelInvalid]);
mToolbarActions.clear();
delete mToolbarServiceExtension;
mToolbarServiceExtension = 0;
if(mVideoServices)
{
mVideoServices->decreaseReferenceCount();
mVideoServices = 0;
}
QList<VideoOperatorService *>::const_iterator iter = mVideoOperatorServices.constBegin();
while(iter != mVideoOperatorServices.constEnd())
{
delete *iter;
iter++;
}
mVideoOperatorServices.clear();
}
// ---------------------------------------------------------------------------
// initialize()
// ---------------------------------------------------------------------------
//
void VideoListToolbar::initialize()
{
if (mUiUtils.isService())
{
INFO("VideoListToolbar::initialize() initializing service.");
if (!mVideoServices)
{
mVideoServices = VideoServices::instance();
}
}
else if(mVideoServices)
{
mVideoServices->decreaseReferenceCount();
mVideoServices = 0;
}
createToolbarActions();
}
// ---------------------------------------------------------------------------
// viewStateChanged()
// ---------------------------------------------------------------------------
//
void VideoListToolbar::viewStateChanged(
VideoCollectionCommon::TCollectionLevels currentLevel,
bool noVideos, bool modelReady)
{
if(!mToolbarViewsActionGroup || !mToolbarCollectionActionGroup)
{
// not initialized yet.
return;
}
if(currentLevel != mCurrentLevel)
{
QList<QAction*> newActions = mViewStateActions[currentLevel];
QList<QAction*> oldActions = mViewStateActions[mCurrentLevel];
mCurrentLevel = currentLevel;
if(newActions != oldActions)
{
emit actionsChanged(newActions);
if(mToolbarServiceExtension &&
(mCurrentLevel == VideoCollectionCommon::ELevelCategory ||
mCurrentLevel == VideoCollectionCommon::ELevelVideos))
{
emit toolbarExtensionChanged(mToolbarServiceExtension);
}
// note don't need to clear the toolbar extension actions, as the
// actionsChanged signal should clear all previous actions.
}
if(mCurrentLevel == VideoCollectionCommon::ELevelVideos &&
!mToolbarActions[ETBActionAllVideos]->isChecked())
{
mToolbarActions[ETBActionAllVideos]->setChecked(true);
}
else if(mCurrentLevel == VideoCollectionCommon::ELevelCategory &&
!mToolbarActions[ETBActionCollections]->isChecked())
{
mToolbarActions[ETBActionCollections]->setChecked(true);
}
}
if(!mVideoServices)
{
if(modelReady)
{
mToolbarActions[ETBActionAddVideos]->setVisible(true);
mToolbarActions[ETBActionRemoveVideos]->setVisible(!noVideos);
}
else
{
mToolbarActions[ETBActionAddVideos]->setVisible(false);
mToolbarActions[ETBActionRemoveVideos]->setVisible(false);
}
}
}
// ---------------------------------------------------------------------------
// createToolbarActions()
// Creates toolbar actions and toolbar icons
// ---------------------------------------------------------------------------
//
void VideoListToolbar::createToolbarActions()
{
FUNC_LOG;
// 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);
// create toolbar item actions
// All Videos tab
mToolbarActions[ETBActionAllVideos] = createAction("qtg_mono_video",
mToolbarViewsActionGroup, SIGNAL(allVideosActionTriggered()));
// Collections tab
mToolbarActions[ETBActionCollections] = createAction("qtg_mono_video_collection",
mToolbarViewsActionGroup, SIGNAL(collectionViewActionTriggered()));
if (!mVideoServices)
{
// Create services button or toolbar extension depending how many operator
// services are configured.
createOperatorServicesToolbarActions();
// Add Videos tab
mToolbarActions[ETBActionAddVideos] =
createAction("qtg_mono_add_to_video_collection",
mToolbarCollectionActionGroup, SLOT(addVideosToCollectionSlot()));
// Remove Videos tab
mToolbarActions[ETBActionRemoveVideos] =
createAction("qtg_mono_remove_from_video_collection",
mToolbarCollectionActionGroup, SLOT(removeVideosFromCollectionSlot()));
}
// Collection view actions are not checkable
mToolbarActions[ETBActionAllVideos]->setCheckable(true);
mToolbarActions[ETBActionCollections]->setCheckable(true);
if(!mVideoServices && mToolbarActions[ETBActionServices])
{
mToolbarActions[ETBActionServices]->setCheckable(false);
}
mViewStateActions[VideoCollectionCommon::ELevelCategory] = mToolbarViewsActionGroup->actions();
mViewStateActions[VideoCollectionCommon::ELevelVideos] = mToolbarViewsActionGroup->actions();
if(!mVideoServices)
{
mViewStateActions[VideoCollectionCommon::ELevelAlbum] = mToolbarCollectionActionGroup->actions();
}
}
}
// ---------------------------------------------------------------------------
// createOperatorServicesToolbar()
// ---------------------------------------------------------------------------
//
void VideoListToolbar::createOperatorServicesToolbarActions()
{
FUNC_LOG;
if(mVideoOperatorServices.count() > 0)
{
return;
}
// Load services.
loadOperatorService(KVideoCollectionViewCenrepServiceItem1Title, KVideoCollectionViewCenrepServiceItem1ToolbarIconPath,
KVideoCollectionViewCenrepServiceItem1Url, KVideoCollectionViewCenrepServiceItem1Uid);
loadOperatorService(KVideoCollectionViewCenrepServiceItem2Title, KVideoCollectionViewCenrepServiceItem2ToolbarIconPath,
KVideoCollectionViewCenrepServiceItem2Url, KVideoCollectionViewCenrepServiceItem2Uid);
loadOperatorService(KVideoCollectionViewCenrepServiceItem3Title, KVideoCollectionViewCenrepServiceItem3ToolbarIconPath,
KVideoCollectionViewCenrepServiceItem3Url, KVideoCollectionViewCenrepServiceItem3Uid);
loadOperatorService(KVideoCollectionViewCenrepServiceItem4Title, KVideoCollectionViewCenrepServiceItem4ToolbarIconPath,
KVideoCollectionViewCenrepServiceItem4Url, KVideoCollectionViewCenrepServiceItem4Uid);
loadOperatorService(KVideoCollectionViewCenrepServiceItem5Title, KVideoCollectionViewCenrepServiceItem5ToolbarIconPath,
KVideoCollectionViewCenrepServiceItem5Url, KVideoCollectionViewCenrepServiceItem5Uid);
loadOperatorService(KVideoCollectionViewCenrepServiceItem6Title, KVideoCollectionViewCenrepServiceItem6ToolbarIconPath,
KVideoCollectionViewCenrepServiceItem6Url, KVideoCollectionViewCenrepServiceItem6Uid);
// Create toolbar extension when there's multiple services.
if(mVideoOperatorServices.count() > 1 && !mToolbarServiceExtension)
{
mToolbarServiceExtension = new HbToolBarExtension();
mToolbarServiceExtension->setObjectName(LIST_VIEW_OBJECT_NAME_TOOLBAR_EXTENSION);
QList<VideoOperatorService *>::const_iterator iter = mVideoOperatorServices.constBegin();
while(iter != mVideoOperatorServices.constEnd())
{
HbIcon icon((*iter)->iconResource());
HbAction *action = mToolbarServiceExtension->addAction(icon, (*iter)->title(),
(*iter), SLOT(launchService()));
action->setObjectName((*iter)->title());
iter++;
}
}
// Add toolbar button when there's only one service.
if(mVideoOperatorServices.count() == 1)
{
VideoOperatorService *service = mVideoOperatorServices[0];
mToolbarActions[ETBActionServices] = createAction(service->iconResource(),
mToolbarViewsActionGroup, 0 /*do not connect to any slot*/);
connect(mToolbarActions[ETBActionServices], SIGNAL(triggered()), service, SLOT(launchService()));
}
}
// ---------------------------------------------------------------------------
// loadOperatorService()
// ---------------------------------------------------------------------------
//
void VideoListToolbar::loadOperatorService(int titleKey, int iconKey, int uriKey, int uidKey)
{
FUNC_LOG;
VideoOperatorService *service = new VideoOperatorService();
if(service->load(titleKey, iconKey, uriKey, uidKey))
{
mVideoOperatorServices.append(service);
}
else
{
// Load failed, delete service data.
delete service;
}
}
// ---------------------------------------------------------------------------
// openOperatorServiceSlot()
// ---------------------------------------------------------------------------
//
void VideoListToolbar::openOperatorServiceSlot()
{
FUNC_LOG;
if(mVideoOperatorServices.count() > 0)
{
mVideoOperatorServices[0]->launchService();
}
}
// -------------------------------------------------------------------------------------------------
// addVideosToCollectionSlot()
// -------------------------------------------------------------------------------------------------
//
void VideoListToolbar::addVideosToCollectionSlot()
{
FUNC_LOG;
VideoListWidget* currentList = mListView->getCurrentList();
if(!currentList || !currentList->getModel())
{
return;
}
VideoListSelectionDialog *dialog =
mUiLoader->findWidget<VideoListSelectionDialog>(
DOCML_NAME_DIALOG);
if (!dialog)
{
// fatal: no selection dialog
return;
}
// 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 && allVideos->getModel())
{
int count = allVideos->getModel()->rowCount();
if(count == currentList->getModel()->rowCount())
{
if(count)
{
QVariant emptyAdditional;
mUiUtils.showStatusMsgSlot(
VideoCollectionCommon::statusAllVideosAlreadyInCollection,
emptyAdditional);
}
return;
}
}
TMPXItemId collectionId = currentList->getModel()->getOpenItem();
dialog->setupContent(VideoListSelectionDialog::EAddToCollection, collectionId);
dialog->exec();
}
// -------------------------------------------------------------------------------------------------
// removeVideosFromCollectionSlot()
// -------------------------------------------------------------------------------------------------
//
void VideoListToolbar::removeVideosFromCollectionSlot()
{
FUNC_LOG;
VideoListWidget* currentList = mListView->getCurrentList();
if(!currentList || !currentList->getModel())
{
return;
}
// not allowed if for some reason current widget
// is all videos or collection or there are no items
if(currentList->getLevel() != VideoCollectionCommon::ELevelAlbum ||
!currentList->getModel()->rowCount())
{
return;
}
VideoListSelectionDialog *dialog =
mUiLoader->findWidget<VideoListSelectionDialog>(
DOCML_NAME_DIALOG);
if (!dialog)
{
ERROR(-1, "VideoListView::removeVideosFromCollectionSlot() failed to load selection dialog.");
return;
}
TMPXItemId collectionId = currentList->getModel()->getOpenItem();
if(collectionId != TMPXItemId::InvalidId() && collectionId.iId2 == KVcxMvcMediaTypeAlbum)
{
dialog->setupContent(VideoListSelectionDialog::ERemoveFromCollection, collectionId);
dialog->exec();
}
}
// ---------------------------------------------------------------------------
// createAction()
// ---------------------------------------------------------------------------
//
HbAction* VideoListToolbar::createAction(QString icon,
QActionGroup* actionGroup, const char *slot)
{
FUNC_LOG;
HbAction* action = new HbAction(actionGroup);
HbIcon hbIcon(icon);
action->setIcon(hbIcon);
if(slot)
{
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;
}
// End of file