--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ui/views/fullscreenview/src/glxfullscreenview.cpp Fri Mar 19 09:28:59 2010 +0200
@@ -0,0 +1,662 @@
+/*
+* 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: ?Description
+*
+*/
+
+
+//Includes
+#include <QDebug>
+#include <QTimer>
+#include <hbmenu.h>
+#include <hbgridview.h>
+#include <hbpushbutton.h>
+#include <hbmainwindow.h>
+#include <shareuidialog.h>
+#include <hbdocumentloader.h>
+#include <QAbstractItemModel>
+#include <hbabstractviewitem.h>
+
+
+//User Includes
+#include "glxviewids.h" //contains the view ids of all the views in photos app.
+#include "glxmodelparm.h"
+#include "glxcoverflow.h"
+#include "glxzoomslider.h"
+#include "glxzoomcontrol.h"
+#include "glxdocloaderdefs.h" //contains the definations of path, widget names and view names in docml
+#include "glxloggerenabler.h"
+#include "glxfullscreenview.h"
+#include "glxcommandhandlers.hrh"
+#include <glxhdmicontroller.h>
+#include <glxlog.h>
+#include <glxtracer.h>
+
+
+const int KUiOffTime = 3000;
+
+GlxFullScreenView::GlxFullScreenView(HbMainWindow *window,HbDocumentLoader *DocLoader) : GlxView ( GLX_FULLSCREENVIEW_ID),
+ mModel(NULL), mWindow( window), mCoverFlow(NULL) , mImageStrip (NULL), mUiOffTimer(NULL),
+ mZmPushButton(NULL), mZoomSlider(NULL), mZoomControl(NULL),mSendUserActivityEvent(false),
+ mFlipPushButton(NULL), nbrCol(0),iHdmiController(NULL)
+{
+ TRACER("GlxFullScreenView::GlxFullScreenView()" );
+ mDocLoader = DocLoader;
+ setContentFullScreen( true );
+ HbEffect::add( QString("HbGridView"), QString(":/data/transitionup.fxml"), QString( "TapShow" ));
+ HbEffect::add( QString("HbGridView"), QString(":/data/transitiondown.fxml"), QString( "TapHide" ));
+}
+
+void GlxFullScreenView::initializeView(QAbstractItemModel *model)
+{
+ TRACER("GlxFullScreenView::initializeView()" );
+
+ //Load/Retrieve the Widgets
+ loadWidgets();
+
+ //Initialize the coverflow and partially creates the coverflow with one image
+ // to make the widget light weight in order to make
+ // transition smooth
+ QRect screen_rect = mWindow->geometry();
+ QSize sz(screen_rect.width(), screen_rect.height());
+ mCoverFlow->partiallyCreate( model, sz);
+}
+
+void GlxFullScreenView::loadWidgets()
+ {
+ TRACER("GlxFullScreenView::loadWidgets()");
+ //Load the View and Widget
+ GlxFullScreenView *view = static_cast<GlxFullScreenView*> (mDocLoader->findWidget(GLXFULLSCREEN_VIEW));
+ mCoverFlow = static_cast<GlxCoverFlow*> (mDocLoader->findWidget(GLXFULLSCREEN_COVERFLOW));
+
+ //initialise the cover flow for basic connections and the rest
+ mCoverFlow->setCoverFlow();
+
+ //Load the IMAGE STRIP & FULLSCREEN TOOLBAR[PUSH BUTTON]
+ mImageStrip = static_cast<HbGridView*> (mDocLoader->findWidget(GLXFULLSCREEN_FILMSTRIP));
+ mFlipPushButton = static_cast<HbPushButton*> (mDocLoader->findWidget(GLXFULLSCREEN_FLIP));
+
+ //When the widget is loaded/retreived the widgets are shown by default.
+ //@to do : hide the widgets by default in docml
+ mImageStrip->hide();
+ mFlipPushButton->hide();
+ }
+
+void GlxFullScreenView::activate()
+ {
+ TRACER("GlxFullScreenView::activate()" );
+
+ mWindow->setItemVisible(Hb::AllItems, FALSE) ;
+
+ if(!mCoverFlow)
+ {
+ //retrives the widgets
+ loadWidgets();
+ }
+
+ loadViewSection();
+
+ if(mZmPushButton == NULL) {
+ mZmPushButton = new HbPushButton("ZM",this);
+ }
+
+ if(NULL == mZoomSlider) {
+ mZoomSlider = new GlxZoomSlider(this);
+ }
+
+ if(NULL == mZoomControl) {
+ mZoomControl = new GlxZoomControl(this);
+ }
+
+ addConnection();
+ hideUi();
+ setLayout();
+ mSendUserActivityEvent = true;
+ if (!iHdmiController)
+ {
+ GLX_LOG_INFO("GlxFullScreenView::activate() - CGlxHdmi" );
+ iHdmiController = CGlxHdmiController::NewL();
+ }
+ }
+
+void GlxFullScreenView::loadViewSection()
+ {
+ TRACER("GlxFullScreenView::loadViewSection()" );
+ bool loaded =true;
+ if( mWindow->orientation() == Qt::Horizontal )
+ {
+ //Load the Landscape section for Horizontal
+ mDocLoader->load(GLXFULLSCREENDOCMLPATH,GLXFULLSCREENLSSECTION,&loaded);
+ }
+ else
+ {
+ //Load the Portrait section for Horizontal
+ mDocLoader->load(GLXFULLSCREENDOCMLPATH,GLXFULLSCREENPTSECTION,&loaded);
+ }
+ }
+
+
+void GlxFullScreenView::resetView()
+ {
+ TRACER("GlxFullScreenView::resetView()" );
+
+ //Clear the 4 icons present in the Coverflow,so that the transition between the views are smooth
+ mCoverFlow->partiallyClean();
+
+ //Clean up the rest of the resources allocated
+ cleanUp();
+ }
+
+void GlxFullScreenView::deActivate()
+ {
+ TRACER("GlxFullScreenView::deActivate()" );
+
+ mWindow->setItemVisible(Hb::AllItems , TRUE);
+
+ //Clean up the rest of the resources allocated
+ cleanUp();
+
+ //deletes the iconitems in the coverflow
+ mCoverFlow->ClearCoverFlow();
+
+ //the coverflow is not deleted as it is loaded by document loader
+ //the coverflow is initialised to null
+ //to just reset to the initial state
+ mCoverFlow = NULL;
+ }
+
+void GlxFullScreenView::cleanUp()
+ {
+ TRACER("GlxFullScreenView::cleanUp()" );
+
+ removeConnection();
+
+ if ( mUiOffTimer ) {
+ GLX_LOG_INFO("GlxFullScreenView::cleanUp() mUiOffTimer" );
+ mUiOffTimer->stop();
+ delete mUiOffTimer;
+ mUiOffTimer = NULL;
+ }
+
+ mSendUserActivityEvent = false;
+
+ if(mZmPushButton) {
+ GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mZmPushButton " );
+ delete mZmPushButton;
+ mZmPushButton = NULL;
+ }
+
+ if(mZoomSlider) {
+ GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mZoomSlider " );
+ delete mZoomSlider;
+ mZoomSlider = NULL;
+ }
+
+ if(mZoomControl) {
+ GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mZoomControl " );
+ delete mZoomControl;
+ mZoomControl = NULL;
+ }
+ if (iHdmiController) {
+ GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete iHdmiController " );
+ delete iHdmiController;
+ iHdmiController = NULL;
+ }
+
+ }
+
+QGraphicsItem * GlxFullScreenView::getAnimationItem(GlxEffect transitionEffect)
+ {
+ TRACER("GlxFullScreenView::getAnimationItem(GlxEffect transitionEffect)");
+ if ( transitionEffect == GRID_TO_FULLSCREEN
+ || transitionEffect == FULLSCREEN_TO_DETAIL
+ || transitionEffect == DETAIL_TO_FULLSCREEN ) {
+ return this;
+ }
+
+ return NULL;
+ }
+
+void GlxFullScreenView::setModel( QAbstractItemModel *model )
+ {
+ TRACER("GlxFullScreenView::setModel( QAbstractItemModel *model )");
+ GLX_LOG_INFO2("GlxFullScreenView::setModel() model %u mModel %u", model, mModel );
+
+ mModel = model;
+ mCoverFlow->setModel(mModel);
+ mZoomSlider->setModel(mModel);
+ mZoomControl->setModel(mModel);
+ setImageStripModel();
+ SetImageToHdmiL(); // for the first image on screen
+ }
+
+void GlxFullScreenView::setModelContext()
+ {
+ TRACER("GlxFullScreenView::setModelContext()");
+ if ( mModel && mWindow ) {
+ GLX_LOG_INFO1("GlxFullScreenView::setModelContext %d", mWindow->orientation() );
+
+ if ( mWindow->orientation() == Qt::Horizontal ) {
+ WRITE_TIMESTAMP("set the fullscreen landscape context")
+ mModel->setData(QModelIndex(), (int)GlxContextLsFs, GlxContextRole );
+ }
+ else {
+ WRITE_TIMESTAMP("set the fullscreen portrait context")
+ mModel->setData(QModelIndex(), (int)GlxContextPtFs, GlxContextRole );
+ }
+ }
+ }
+
+void GlxFullScreenView::orientationChanged(Qt::Orientation orient)
+ {
+ TRACER("GlxFullScreenView::orientationChanged()");
+ // fullscreen thumnail size is depends on orientation of phone so change the model context before changing the layout
+ GLX_LOG_INFO1("GlxFullScreenView::orientationChanged() %d", orient );
+ setModelContext();
+ loadViewSection();
+ setLayout();
+ }
+
+void GlxFullScreenView::activateUI()
+ {
+ TRACER("GlxFullScreenView::activateUI()");
+ GLX_LOG_INFO1("GlxFullScreenView::activateUI() %d", mUiOff );
+ if(mSendUserActivityEvent){
+ mSendUserActivityEvent = false;
+ emit cancelTimer();
+ }
+ if ( mUiOff ){
+
+ if ( mUiOffTimer == NULL ) {
+ mUiOffTimer = new QTimer();
+ connect(mUiOffTimer, SIGNAL(timeout()), this, SLOT(hideUi()));
+ }
+
+ //set and scrool the current index to the center
+ QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );
+ if ( variant.isValid() && variant.canConvert<int> () ) {
+ mImageStrip->setCurrentIndex ( mModel->index( variant.value<int>(), 0) );
+ mImageStrip->scrollTo( mModel->index( variant.value<int>(), 0), HbGridView::PositionAtCenter );
+ }
+ mImageStrip->show();
+
+ //mZmPushButton->show();
+ mFlipPushButton->setZValue( 6 + mCoverFlow->zValue() );
+ mFlipPushButton->show();
+ mZmPushButton->hide();
+ mUiOff = FALSE;
+ mUiOffTimer->start(KUiOffTime);
+ mCoverFlow->setUiOn(TRUE);
+ mWindow->setItemVisible(Hb::AllItems, TRUE) ;
+ HbEffect::start(mImageStrip, QString("HbGridView"), QString("TapShow"), this, "effectFinished" );
+ }
+ else {
+ hideUi();
+ }
+ }
+
+void GlxFullScreenView::hideUi()
+ {
+ TRACER("GlxFullScreenView::hideUi()");
+ GLX_LOG_INFO1("GlxFullScreenView::hideUi() %d", mUiOff );
+ if(mSendUserActivityEvent){
+ mSendUserActivityEvent = false;
+ emit cancelTimer();
+ }
+ HbMenu *menuWidget = menu();
+
+ //if option menu is open then no need to hide the status bar and image strip
+ if ( menuWidget->isVisible() ) {
+ return ;
+ }
+
+ mWindow->setItemVisible(Hb::AllItems, FALSE) ;
+ if ( mImageStrip ) {
+ HbEffect::start(mImageStrip, QString("HbGridView"), QString("TapHide"), this, "effectFinished" );
+ //mImageStrip->hide();
+ }
+ mZmPushButton->hide();
+
+ if(mFlipPushButton){
+ mFlipPushButton->hide();
+ }
+
+ if ( mUiOffTimer ) {
+ mUiOffTimer->stop();
+ }
+ mUiOff = TRUE;
+ mCoverFlow->setUiOn(FALSE);
+ }
+
+void GlxFullScreenView::changeSelectedIndex(const QModelIndex &index)
+ {
+ TRACER("GlxFullScreenView::changeSelectedIndex()");
+ GLX_LOG_INFO1("GlxFullScreenView::changeSelectedIndex() %d", index.row() );
+ QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );
+ if ( variant.isValid() && variant.canConvert<int> () && ( index.row() == variant.value<int>() ) ) {
+ return;
+ }
+ mModel->setData( index, index.row(), GlxFocusIndexRole );
+ mZoomSlider->indexChanged(index.row());
+ // mZoomControl->indexChanged(index.row());
+ SetImageToHdmiL(); // for the image changed on swipe
+ }
+
+void GlxFullScreenView::indexChanged(const QModelIndex &index)
+ {
+ TRACER("GlxFullScreenView::indexChanged()");
+ GLX_LOG_INFO1("GlxFullScreenView::indexChanged() %d", index.row() );
+ QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );
+ if ( variant.isValid() && variant.canConvert<int> () && ( index.row() == variant.value<int>() ) ) {
+ return;
+ }
+ mModel->setData( index, index.row(), GlxFocusIndexRole );
+ mCoverFlow->indexChanged(index.row());
+ mZoomSlider->indexChanged(index.row());
+ mImageStrip->scrollTo(index, HbGridView::PositionAtCenter );
+ //mZoomControl->indexChanged(index.row());
+ SetImageToHdmiL(); // for the indexchnaged through filmstrip
+ }
+
+void GlxFullScreenView::scrollingStarted()
+ {
+ TRACER("GlxFullScreenView::scrollingStarted() ");
+ //no need to hide the ui during image strip scrolling
+ if ( mUiOffTimer ) {
+ mUiOffTimer->stop();
+ }
+ }
+
+void GlxFullScreenView::scrollingEnded()
+ {
+ TRACER("GlxFullScreenView::scrollingEnded() ");
+ if ( mUiOffTimer ) {
+ mUiOffTimer->start(KUiOffTime);
+ }
+ setVisvalWindowIndex();
+ }
+
+void GlxFullScreenView::pressed(const QModelIndex &index)
+ {
+ Q_UNUSED(index)
+ TRACER("GlxFullScreenView::pressed() ");
+ if ( mUiOffTimer ) {
+ mUiOffTimer->stop();
+ }
+ }
+
+void GlxFullScreenView::released(const QModelIndex &index)
+ {
+ Q_UNUSED(index)
+ TRACER("GlxFullScreenView::released() ");
+
+ if ( mUiOffTimer && mImageStrip->isScrolling() == false ) {
+ mUiOffTimer->start(KUiOffTime);
+ }
+ }
+
+void GlxFullScreenView::setVisvalWindowIndex()
+ {
+ TRACER("GlxFullScreenView::setVisvalWindowIndex()");
+ QList< HbAbstractViewItem * > visibleItemList = mImageStrip->visibleItems();
+
+ GLX_LOG_INFO1("GlxFullScreenView::setVisvalWindowIndex() %d", visibleItemList.count());
+ if ( visibleItemList.count() <= 0 )
+ return ;
+
+ HbAbstractViewItem *item = visibleItemList.at(0);
+ GLX_LOG_INFO1("GlxFullScreenView::setVisvalWindowIndex()1 item %u", item);
+ if ( item == NULL )
+ return ;
+
+ GLX_LOG_INFO1("GlxFullScreenView::setVisvalWindowIndex() item %u", item);
+
+ GLX_LOG_INFO1("GlxFullScreenView::setVisvalWindowIndex() visual index %d", item->modelIndex().row() );
+ if ( item->modelIndex().row() < 0 || item->modelIndex().row() >= mModel->rowCount() )
+ return ;
+
+ mModel->setData( item->modelIndex (), item->modelIndex().row(), GlxVisualWindowIndex);
+ }
+
+void GlxFullScreenView::coverFlowEventHandle( GlxCoverFlowEvent e )
+ {
+ TRACER("GlxFullScreenView::coverFlowEventHandle()");
+ switch( e ){
+ case TAP_EVENT :
+ activateUI();
+ break ;
+
+ case PANNING_START_EVENT :
+ hideUi();
+ break ;
+
+ case EMPTY_ROW_EVENT :
+ emit actionTriggered( EGlxCmdEmptyData );
+ break ;
+
+ default :
+ break ;
+ }
+}
+
+void GlxFullScreenView::setLayout()
+ {
+ TRACER("GlxFullScreenView::setLayout()");
+ //TO:DO read form layout doc
+ GLX_LOG_INFO1("GlxFullScreenView::setLayout() %d", mWindow->orientation() );
+
+ QRect screen_rect = mWindow->geometry();
+ QSize sz(screen_rect.width(), screen_rect.height());
+
+
+ mCoverFlow->setItemSize(sz);
+ mZoomControl->setGeometry(screen_rect);
+ mZoomControl->setWindowSize(sz);
+
+ mZmPushButton->setZValue(6);
+ mZmPushButton->setGeometry(QRectF(0,50,50,50));
+ }
+
+void GlxFullScreenView::addConnection()
+ {
+ TRACER("GlxFullScreenView::addConnection() " );
+ if ( mCoverFlow ) {
+ connect( mCoverFlow, SIGNAL( coverFlowEvent( GlxCoverFlowEvent ) ), this, SLOT( coverFlowEventHandle( GlxCoverFlowEvent ) ) );
+ connect( mCoverFlow, SIGNAL(changeSelectedIndex(const QModelIndex &)), this, SLOT( changeSelectedIndex( const QModelIndex & )));
+
+ }
+
+ if ( mImageStrip ) {
+ connect(mImageStrip, SIGNAL( activated(const QModelIndex &) ), this, SLOT( indexChanged(const QModelIndex &) ));
+ connect(mImageStrip, SIGNAL( scrollingStarted()), this, SLOT( scrollingStarted()));
+ connect(mImageStrip, SIGNAL( scrollingEnded()), this, SLOT( scrollingEnded()));
+ connect(mImageStrip, SIGNAL( pressed(const QModelIndex &) ), this, SLOT( pressed(const QModelIndex &) ));
+ connect(mImageStrip, SIGNAL( released(const QModelIndex &) ), this, SLOT( released(const QModelIndex &) ));
+ }
+
+ if ( mUiOffTimer ) {
+ connect(mUiOffTimer, SIGNAL(timeout()), this, SLOT(hideUi()));
+ }
+ //for Zoom
+ if(mZmPushButton &&mZoomSlider) {
+ connect(mZmPushButton, SIGNAL(clicked()), mZoomSlider, SLOT(toggleSliderVisibility()));
+ }
+
+ if(mFlipPushButton)
+ {
+ connect(mFlipPushButton, SIGNAL(clicked()), this, SLOT(showdetailsview()), Qt::QueuedConnection);
+ }
+
+
+ if(mZoomControl && mZoomSlider) {
+ connect(mZoomSlider, SIGNAL(initialZoomFactor(int)), mZoomControl, SLOT(initialZoomFactor(int)));
+ connect(mZoomSlider, SIGNAL(valueChanged(int)), mZoomControl, SLOT(zoomImage(int)));
+ connect(mZoomControl, SIGNAL(hideFullScreenUi()), this, SLOT(hideUi()));
+ }
+
+ connect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationChanged(Qt::Orientation)));
+ }
+
+void GlxFullScreenView::removeConnection()
+ {
+ TRACER("GlxFullScreenView::removeConnection() " );
+
+ if ( mCoverFlow ) {
+ GLX_LOG_INFO("GlxFullScreenView::removeConnection() mCoverFlow " );
+ disconnect( mCoverFlow, SIGNAL( coverFlowEvent( GlxCoverFlowEvent ) ), this, SLOT( coverFlowEventHandle( GlxCoverFlowEvent ) ) );
+ disconnect( mCoverFlow, SIGNAL(changeSelectedIndex(const QModelIndex &)), this, SLOT( changeSelectedIndex( const QModelIndex & )));
+
+ }
+
+ //For Image Strip
+ if ( mImageStrip ) {
+ GLX_LOG_INFO("GlxFullScreenView::removeConnection() mImageStrip " );
+ disconnect(mImageStrip, SIGNAL( activated(const QModelIndex &) ), this, SLOT( indexChanged(const QModelIndex &) ));
+ disconnect(mImageStrip, SIGNAL( scrollingStarted()), this, SLOT( scrollingStarted()));
+ disconnect(mImageStrip, SIGNAL( scrollingEnded()), this, SLOT( scrollingEnded()));
+ disconnect(mImageStrip, SIGNAL( pressed(const QModelIndex &) ), this, SLOT( pressed(const QModelIndex &) ));
+ disconnect(mImageStrip, SIGNAL( released(const QModelIndex &) ), this, SLOT( released(const QModelIndex &) ));
+ }
+
+ if ( mUiOffTimer ) {
+ GLX_LOG_INFO("GlxFullScreenView::removeConnection() mUiOffTimer " );
+ disconnect(mUiOffTimer, SIGNAL(timeout()), this, SLOT(hideUi()));
+ }
+
+ //for Zoom
+ if(mZmPushButton &&mZoomSlider) {
+ GLX_LOG_INFO("GlxFullScreenView::removeConnection() mZoomSlider " );
+ disconnect(mZmPushButton, SIGNAL(clicked()), mZoomSlider, SLOT(toggleSliderVisibility()));
+ }
+
+ if(mZoomControl &&mZoomSlider) {
+ GLX_LOG_INFO("GlxFullScreenView::removeConnection() mZoomSlider " );
+ disconnect(mZoomSlider, SIGNAL(initialZoomFactor(int)), mZoomControl, SLOT(initialZoomFactor(int)));
+ disconnect(mZoomSlider, SIGNAL(valueChanged(int)), mZoomControl, SLOT(zoomImage(int)));
+ disconnect(mZoomControl, SIGNAL(hideFullScreenUi()), this, SLOT(hideUi()));
+ }
+
+ //for Details view launching
+ if(mFlipPushButton) {
+ GLX_LOG_INFO("GlxFullScreenView::removeConnection() mFlipPushButton " );
+ disconnect(mFlipPushButton, SIGNAL(clicked()), this, SLOT(showdetailsview()));
+ }
+
+ disconnect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationChanged(Qt::Orientation)));
+ }
+
+void GlxFullScreenView::setImageStripModel()
+ {
+ TRACER("GlxFullScreenView::setImageStripModel()" );
+ if ( mModel && mImageStrip ) {
+ mImageStrip->setModel( mModel );
+ QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );
+ if ( variant.isValid() && variant.canConvert<int> () ) {
+ mImageStrip->setCurrentIndex ( mModel->index( variant.value<int>(), 0) );
+ }
+ }
+ }
+
+GlxFullScreenView::~GlxFullScreenView()
+ {
+ TRACER("GlxFullScreenView::~GlxFullScreenView()" );
+ cleanUp();
+
+ if(mImageStrip) {
+ GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mImageStrip " );
+ delete mImageStrip;
+ mImageStrip = NULL;
+ }
+
+ if(mFlipPushButton) {
+ GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mFlipPushButton " );
+ delete mFlipPushButton;
+ mFlipPushButton = NULL;
+ }
+
+ if(mCoverFlow) {
+ GLX_LOG_INFO("GlxFullScreenView::~GlxFullScreenView() delete mCoverFlow " );
+ delete mCoverFlow;
+ mCoverFlow = NULL;
+ }
+
+ if(mDocLoader != NULL)
+ {
+ mDocLoader->reset();
+ delete mDocLoader;
+ }
+ HbEffect::remove( QString("HbGridView"), QString(":/data/transitionup.fxml"), QString( "TapShow" ));
+ HbEffect::remove( QString("HbGridView"), QString(":/data/transitiondown.fxml"), QString( "TapHide" ));
+ }
+
+void GlxFullScreenView::showdetailsview()
+ {
+ TRACER("GlxFullScreenView::showdetailsview()" );
+ //trigger the details view to be shown
+ emit actionTriggered( EGlxCmdDetailsOpen );
+ }
+
+void GlxFullScreenView::handleUserAction(qint32 commandId)
+ {
+ TRACER("GlxFullScreenView::handleUserAction()" );
+ switch( commandId )
+ {
+ case EGlxCmdRotate :
+ //trigger the rotate Effect in CoverFlow
+ mCoverFlow->rotateImage();
+ break;
+ case EGlxCmdSend:
+ {
+ QString imagePath = (mModel->data(mModel->index(mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>(),0),GlxUriRole)).value<QString>();
+ if(imagePath.isNull())
+ {
+ GLX_LOG_INFO("GlxFullScreenView::SendUi() path is null" );
+ }
+ qDebug() << "GlxFullScreenView::SendUi() imagePath= " << imagePath;
+
+ ShareUi dialog;
+ QList <QVariant> fileList;
+ fileList.append(QVariant(imagePath));
+ dialog.init(fileList,true);
+ }
+ break;
+ default :
+ break;
+ }
+ }
+
+void GlxFullScreenView::SetImageToHdmiL()
+ {
+ TRACER("GlxFullScreenView::SetImageToHdmiL() - CGlxHdmi 1" );
+ if (iHdmiController)
+ {
+ GLX_LOG_INFO("GlxFullScreenView::SetImageToHdmiL() - CGlxHdmi 2" );
+ // Get the image uri
+ QString imagePath = (mModel->data(mModel->index(mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>(),0),GlxUriRole)).value<QString>();
+ if(imagePath.isNull())
+ {
+ GLX_LOG_INFO("GlxFullScreenView::SetImageToHdmiL() path is null" );
+ }
+ qDebug() << "GlxFullScreenView::SetImageToHdmiL() imagePath= " << imagePath;
+ TPtrC aPtr = reinterpret_cast<const TUint16*>(imagePath.utf16());
+
+ // Get the image Dimensions
+ QSize imageDimension = (mModel->data(mModel->index(mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>(),0),GlxDimensionsRole)).value<QSize>();
+ TSize imageSize(imageDimension.width(),imageDimension.height());
+
+ // Get the framecount
+ int frameCount = (mModel->data(mModel->index(mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>(),0),GlxFrameCount)).value<int>();
+ iHdmiController->SetImageL(aPtr,imageSize, frameCount);
+ }
+ }