--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ui/views/fullscreenview/src/glxfullscreenview.cpp Tue Aug 31 15:14:51 2010 +0300
@@ -0,0 +1,916 @@
+/*
+* 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 <QTimer>
+#include <hbmenu.h>
+#include <HbAction>
+#include <HbToolBar>
+#include <hbgridview.h>
+#include <hbpushbutton.h>
+#include <hbmainwindow.h>
+#include <shareuidialog.h>
+#include <hbdocumentloader.h>
+#include <QAbstractItemModel>
+#include <hbabstractviewitem.h>
+#include <hbiconitem.h>
+#include <QCoreApplication>
+#include <xqserviceutil.h>
+//User Includes
+#include "glxlog.h"
+#include "glxtracer.h"
+#include "glxviewids.h" //contains the view ids of all the views in photos app.
+#include "glxicondefs.h" //Contains the icon names/Ids
+#include "glxmodelparm.h"
+#include "glxcoverflow.h"
+#include "glxdocloaderdefs.h" //contains the definations of path, widget names and view names in docml
+#include "glxloggerenabler.h"
+#include "glxtvoutwrapper.h"
+#include "glxfullscreenview.h"
+#include "glxcommandhandlers.hrh"
+#include "glxzoomwidget.h"
+#include "glxlocalisationstrings.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "glxfullscreenviewTraces.h"
+#endif
+
+
+const int KUiOffTime = 3000;
+
+GlxFullScreenView::GlxFullScreenView(HbMainWindow *window,HbDocumentLoader *DocLoader) :
+ GlxView ( GLX_FULLSCREENVIEW_ID ),
+ mModel( NULL ),
+ mWindow( window ),
+ mCoverFlow( NULL ) ,
+ mImageStrip( NULL ),
+ mUiOffTimer( NULL ),
+ mBackGroundItem( NULL ),
+ mTvOutWrapper( NULL ),
+ mFullScreenToolBar( NULL ),
+ mZoomWidget( NULL ),
+ mUiOff ( false )
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_GLXFULLSCREENVIEW_ENTRY );
+ mIconItems[0] = NULL;
+ mIconItems[1] = NULL;
+ mDocLoader = DocLoader;
+ setContentFullScreen( true );
+
+ HbEffect::add( QString( "HbGridView" ), QString( ":/data/transitionup.fxml" ), QString( "TapShow" ) );
+ HbEffect::add( QString( "HbGridView" ), QString( ":/data/transitiondown.fxml" ), QString( "TapHide" ) );
+ HbEffect::add( QString( "HbGridViewItem" ), QString( ":/data/zoomin.fxml" ), QString( "SelectHide" ) );
+ HbEffect::add( QString( "HbGridViewItem" ), QString( ":/data/zoomout.fxml" ), QString( "SelectShow" ) );
+ HbEffect::add( QString( "HbIconItem" ), QString( ":/data/rotatefslandscape.fxml" ), QString( "RotateFSLS" ) );
+ HbEffect::add( QString( "HbIconItem" ), QString( ":/data/rotatefsprotrait.fxml" ), QString( "RotateFSPT" ) );
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_GLXFULLSCREENVIEW_EXIT );
+}
+
+void GlxFullScreenView::initializeView( QAbstractItemModel *model, GlxView *preView )
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_INITIALIZEVIEW_ENTRY );
+
+ // if animations is on, then Set the image to HDMI here
+ if (!mTvOutWrapper){
+ mTvOutWrapper = new GlxTvOutWrapper();
+ }
+ setHdmiModel(model);
+ loadWidgets();
+
+ /*
+ * Initialize the coverflow and partially creates the coverflow with one image
+ * to make the widget light weight in order to make transition smooth
+ */
+ /*
+ * Grid view is not in full screen mode so this view have some flicker after transtion is finshed
+ * and some cases in grid view status bar is visible and some cases it is not
+ * so adjust the initial postion of fullscreen base on status bar visiblity.
+ */
+ if ( preView->compare( GLX_GRIDVIEW_ID ) && preView->isItemVisible ( Hb::StatusBarItem ) ) {
+ qreal chromeHeight = 0;
+ style()->parameter( "hb-param-widget-chrome-height", chromeHeight );
+ mCoverFlow->partiallyCreate( model, screenSize(), -chromeHeight );
+ }
+ else {
+ mCoverFlow->partiallyCreate( model, screenSize() );
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_INITIALIZEVIEW_EXIT );
+}
+
+void GlxFullScreenView::loadWidgets()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_LOADWIDGETS_ENTRY );
+
+ mCoverFlow = qobject_cast<GlxCoverFlow*> (mDocLoader->findWidget(GLXFULLSCREEN_COVERFLOW));
+
+ mZoomWidget = qobject_cast<GlxZoomWidget*> (mDocLoader->findWidget(GLXFULLSCREENZOOMWIDGET));
+ mZoomWidget->connectDecodeRequestToPinchEvent();
+ mCoverFlow->setMultitouchFilter(mZoomWidget);
+
+ //initialise the cover flow for basic connections and the rest
+ mCoverFlow->setCoverFlow();
+ mImageStrip = qobject_cast<HbGridView*> (mDocLoader->findWidget(GLXFULLSCREEN_FILMSTRIP));
+
+ //When the widget is loaded/retreived the widgets are shown by default.
+ //@to do : hide the widgets by default in docml
+ mImageStrip->hide();
+ mImageStrip->setLayoutName( QString( "ImageStrip" ) ); // To distinguish in CSS file
+ mImageStrip->setEnabledAnimations( HbAbstractItemView::None );
+ mImageStrip->setHorizontalScrollBarPolicy( HbScrollArea::ScrollBarAlwaysOff );
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_LOADWIDGETS_EXIT );
+}
+
+void GlxFullScreenView::loadFullScreenToolBar()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_LOADFULLSCREENTOOLBAR_ENTRY );
+
+ //The fullscreen tool bar is delted when ever the view is deactivated
+ //so load the docml once again and retreive the object
+ bool loaded =true;
+ mDocLoader->load(GLXFULLSCREENDOCMLPATH,&loaded);
+ loadViewSection();
+
+ mFullScreenToolBar = qobject_cast<HbToolBar *> (mDocLoader->findObject(QString("toolBar")));
+ mFullScreenToolBar->clearActions();
+
+ addToolBarAction( EGlxCmdDetailsOpen, GLXICON_FLIP, "Flip Action" ); //create Flip tool bar button action
+ addToolBarAction( EGlxCmdSend, GLXICON_SEND, "Send Action" ); //create Send tool bar button action
+ if( getSubState() != IMAGEVIEWER_S ) {
+ addToolBarAction( EGlxCmdDelete, GLXICON_DELETE, "Delete Action" ); //create Delete tool bar button action
+ }
+ else {
+ addToolBarAction( EGlxCmdHandled, GLXICON_USEIMAGE, "Use Action" ); //create Use Image tool bar button action
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_LOADFULLSCREENTOOLBAR_EXIT );
+}
+
+void GlxFullScreenView::addToolBarAction( int commandId, const QString &iconName, const QString &name )
+{
+ HbAction *action = new HbAction( this );
+ action->setData( commandId );
+ action->setIcon( HbIcon( iconName ) );
+ action->setObjectName( name );
+ mFullScreenToolBar->addAction( action );
+ connect(action, SIGNAL(triggered( )), this, SLOT(handleToolBarAction( )) );
+}
+
+void GlxFullScreenView::activate()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_ACTIVATE_ENTRY );
+//for zoom might not be required after wk15 release
+ mWindow->viewport()->setAttribute(Qt::WA_AcceptTouchEvents,true);
+ mWindow->viewport()->grabGesture(Qt::PinchGesture);
+
+ QCoreApplication::instance()->installEventFilter(this);
+
+ if( !mCoverFlow ) {
+ loadWidgets(); //retrives the widgets
+ }
+ //Loads the widgets corresponding to the orientation.
+ loadViewSection();
+
+ HbView::HbViewFlags flags( HbView::ViewTitleBarTransparent | HbView::ViewStatusBarTransparent);
+ setViewFlags(flags);
+
+ // In case of fetcher don't hide status pane and title bar
+ if(!(XQServiceUtil::isService() && (0 == XQServiceUtil::interfaceName().compare(QLatin1String("com.nokia.symbian.IImageFetch"))))) {
+ setViewFlags( viewFlags() | HbView::ViewTitleBarHidden | HbView::ViewStatusBarHidden );
+ mUiOff = true;
+ }
+ else
+ {
+ HbAction* selectAction = new HbAction(GLX_BUTTON_SELECT);
+ selectAction->setObjectName( "FS Select" );
+
+ connect(selectAction, SIGNAL(triggered()), this, SLOT(handleFSSelect()));
+ HbToolBar* toolBar = new HbToolBar();
+ toolBar->setOrientation( Qt::Horizontal );
+ toolBar->setVisible(true);
+ toolBar->addAction(selectAction);
+ setToolBar(toolBar);
+ }
+
+ mUiOffTimer = new QTimer();
+ mUiOffTimer->stop();
+ mCoverFlow->setUiOn(FALSE);
+ addConnection();
+ setLayout();
+
+ if (!mTvOutWrapper) {
+ mTvOutWrapper = new GlxTvOutWrapper();
+ }
+
+ mWindow->setAutomaticOrientationEffectEnabled( false );
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_ACTIVATE_EXIT );
+}
+
+void GlxFullScreenView::handleFSSelect()
+{
+ emit actionTriggered( EGlxCmdFetcherSelect );
+}
+
+void GlxFullScreenView::loadViewSection()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_LOADVIEWSECTION_ENTRY );
+
+ 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);
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_LOADVIEWSECTION_EXIT );
+}
+
+void GlxFullScreenView::resetView()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_RESETVIEW_ENTRY );
+
+ cancelSelectionAnimation(); //cancel the image selection effect before cleaning the view
+ //Clean up the rest of the resources allocated
+ cleanUp();
+
+ //Clear the 4 icons present in the Coverflow,so that the transition between the views are smooth
+ mCoverFlow->partiallyClean();
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_RESETVIEW_EXIT );
+}
+
+void GlxFullScreenView::deActivate()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_DEACTIVATE_ENTRY );
+
+ cancelSelectionAnimation(); //cancel the image selection effect before cleaning the view
+ //Clean up the rest of the resources allocated
+ cleanUp();
+ QCoreApplication::instance()->removeEventFilter(this);
+ //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;
+ mWindow->setAutomaticOrientationEffectEnabled( true );
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_DEACTIVATE_EXIT );
+}
+
+void GlxFullScreenView::cleanUp()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_CLEANUP_ENTRY );
+
+ removeConnection();
+
+ if ( mUiOffTimer ) {
+ OstTrace0( TRACE_NORMAL, GLXFULLSCREENVIEW_CLEANUP, "GlxFullScreenView::cleanUp() mUiOffTimer" );
+ mUiOffTimer->stop();
+ delete mUiOffTimer;
+ mUiOffTimer = NULL;
+ }
+
+ if(mFullScreenToolBar) {
+ mFullScreenToolBar->clearActions();
+ mFullScreenToolBar->hide();
+ mFullScreenToolBar = NULL;
+ }
+
+ if (mTvOutWrapper) {
+ delete mTvOutWrapper;
+ mTvOutWrapper = NULL;
+ }
+
+ if(mZoomWidget)
+ {
+ mZoomWidget->cleanUp();
+ mZoomWidget = NULL;
+ }
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_CLEANUP_EXIT );
+}
+
+QGraphicsItem * 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 )
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SETMODEL_ENTRY );
+ OstTraceExt2( TRACE_NORMAL, GLXFULLSCREENVIEW_SETMODEL, "GlxFullScreenView::setModel; model=%x; mModel=%u", ( TUint )( model ), ( TUint ) mModel );
+
+ mModel = model;
+ setModelContext();
+ setHdmiModel(mModel);
+ mZoomWidget->setModel(mModel);
+ mCoverFlow->setModel(mModel);
+ setImageStripModel();
+ if(getSubState() == IMAGEVIEWER_S) {
+ setTitle(GLX_IMAGE_VIEWER);
+ }
+ else if(getSubState() == FETCHER_S){ //do not zoom in case of fetcher
+ disconnect(mCoverFlow,SIGNAL( doubleTapEventReceived(QPointF) ), mZoomWidget, SLOT( animateZoomIn(QPointF) ) );
+ }
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_SETMODEL_EXIT );
+}
+
+void GlxFullScreenView::setHdmiModel(QAbstractItemModel* model)
+{
+ if (mTvOutWrapper) {
+ mTvOutWrapper->setModel(model, screenSize());
+ mTvOutWrapper->setImagetoHDMI(); // for the first image on screen
+ }
+}
+
+void GlxFullScreenView::setModelContext()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SETMODELCONTEXT_ENTRY );
+
+ if ( mModel && mWindow ) {
+ 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 );
+ }
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_SETMODELCONTEXT_EXIT );
+}
+
+void GlxFullScreenView::orientationChanged(Qt::Orientation orient)
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_ORIENTATIONCHANGED_ENTRY );
+ Q_UNUSED(orient)
+
+ // fullscreen thumnail size is depends on orientation of phone so change the model context before changing the layout
+ if ( mUiOff == FALSE ) {
+ mUiOffTimer->start(KUiOffTime);
+ }
+ setModelContext();
+ loadViewSection();
+ setLayout();
+
+ if ( mZoomWidget->zValue() >= mCoverFlow->zValue() ) {
+ playZoomOrientChangeAnim();
+ }
+ else {
+ playOrientChangeAnim();
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_ORIENTATIONCHANGED_EXIT );
+}
+
+void GlxFullScreenView::activateUI()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_ACTIVATEUI_ENTRY );
+
+ if ( mUiOff && getSubState() != FETCHER_S ){
+ if( !mFullScreenToolBar ) {
+ loadFullScreenToolBar();
+ }
+ mUiOff = FALSE;
+
+ 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::PositionAtTop );
+ }
+
+ setItemVisible( Hb::AllItems, TRUE );
+ setViewFlags( viewFlags() &~ HbView::ViewTitleBarHidden &~ HbView::ViewStatusBarHidden );
+
+ if ( mImageStrip && getSubState() != IMAGEVIEWER_S) {
+ mImageStrip->show();
+ HbEffect::start(mImageStrip, QString("HbGridView"), QString("TapShow"), this, "effectFinished" );
+ }
+ else if( getSubState() == IMAGEVIEWER_S){
+ setTitle(GLX_IMAGE_VIEWER);
+ }
+ mFullScreenToolBar->setOpacity( 1 );
+ mFullScreenToolBar->show();
+ }
+ else {
+ hideUi();
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_ACTIVATEUI_EXIT );
+}
+
+void GlxFullScreenView::hideUi()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_HIDEUI_ENTRY );
+
+ //if option menu is open then no need to hide the status bar and image strip
+ HbMenu *menuWidget = menu();
+ if ( menuWidget->isVisible() ) {
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_HIDEUI_EXIT );
+ return ;
+ }
+
+ mUiOff = TRUE;
+ if ( getSubState() != FETCHER_S ) {
+ setViewFlags( viewFlags() | HbView::ViewTitleBarHidden | HbView::ViewStatusBarHidden );
+ }
+ if ( mImageStrip && ( getSubState() != IMAGEVIEWER_S && getSubState() != FETCHER_S ) ) {
+ HbEffect::start( mImageStrip, QString("HbGridView"), QString("TapHide"), this, "effectFinished" );
+ }
+
+ if(mFullScreenToolBar) {
+ mFullScreenToolBar->hide();
+ }
+
+ OstTraceFunctionExit0( DUP1_GLXFULLSCREENVIEW_HIDEUI_EXIT );
+}
+
+void GlxFullScreenView::changeSelectedIndex(const QModelIndex &index)
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_CHANGESELECTEDINDEX_ENTRY );
+
+ QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );
+ if ( variant.isValid() && variant.canConvert<int> () && ( index.row() == variant.value<int>() ) ) {
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_CHANGESELECTEDINDEX_EXIT );
+ if (mTvOutWrapper){
+ // for the image changed on deletion
+ mTvOutWrapper->setImagetoHDMI();
+ }
+ if (mZoomWidget){
+ // for the image changed on deletion
+ mZoomWidget->indexChanged();
+ }
+ return;
+ }
+
+ mModel->setData( index, index.row(), GlxFocusIndexRole );
+ mModel->setData( index, index.row(), GlxVisualWindowIndex );
+ mZoomWidget->indexChanged(index.row());
+
+ if (mTvOutWrapper){
+ // for the image changed on swipe
+ mTvOutWrapper->setImagetoHDMI();
+ }
+ OstTraceFunctionExit0( DUP1_GLXFULLSCREENVIEW_CHANGESELECTEDINDEX_EXIT );
+}
+
+void GlxFullScreenView::indexChanged(const QModelIndex &index)
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_INDEXCHANGED_ENTRY );
+
+ QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );
+ if ( variant.isValid() && variant.canConvert<int> () && ( index.row() == variant.value<int>() ) ) {
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_INDEXCHANGED_EXIT );
+ return;
+ }
+
+ if (mTvOutWrapper){
+ // for the indexchnaged through filmstrip
+ mTvOutWrapper->setImagetoHDMI();
+ }
+ //disable the animation for the time being
+ imageSelectionAnimation( index );
+
+ mModel->setData( index, index.row(), GlxFocusIndexRole );
+ mZoomWidget->indexChanged(index.row());
+ mZoomWidget->setVisible( false );
+
+ OstTraceFunctionExit0( DUP1_GLXFULLSCREENVIEW_INDEXCHANGED_EXIT );
+}
+
+void GlxFullScreenView::scrollingStarted()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SCROLLINGSTARTED_ENTRY );
+
+ //no need to hide the ui during image strip scrolling
+ if ( mUiOffTimer ) {
+ mUiOffTimer->stop();
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_SCROLLINGSTARTED_EXIT );
+}
+
+void GlxFullScreenView::scrollingEnded()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SCROLLINGENDED_ENTRY );
+
+ if ( mUiOffTimer ) {
+ mUiOffTimer->start(KUiOffTime);
+ }
+ setVisvalWindowIndex();
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_SCROLLINGENDED_EXIT );
+}
+
+void GlxFullScreenView::pressed(const QModelIndex &index)
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_PRESSED_ENTRY );
+
+ Q_UNUSED(index)
+ TRACER("GlxFullScreenView::pressed() ");
+ if ( mUiOffTimer ) {
+ mUiOffTimer->stop();
+ }
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_PRESSED_EXIT );
+}
+
+void GlxFullScreenView::released(const QModelIndex &index)
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_RELEASED_ENTRY );
+
+ Q_UNUSED(index)
+
+ if ( mUiOffTimer && mImageStrip->isScrolling() == false ) {
+ mUiOffTimer->start(KUiOffTime);
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_RELEASED_EXIT );
+}
+
+void GlxFullScreenView::setVisvalWindowIndex()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SETVISVALWINDOWINDEX_ENTRY );
+
+ QList< HbAbstractViewItem * > visibleItemList = mImageStrip->visibleItems();
+ if ( visibleItemList.count() <= 0 )
+ return ;
+
+ HbAbstractViewItem *item = visibleItemList.at(0);
+ if ( item == NULL )
+ return ;
+
+ if ( item->modelIndex().row() < 0 || item->modelIndex().row() >= mModel->rowCount() )
+ return ;
+
+ mModel->setData( item->modelIndex (), item->modelIndex().row(), GlxVisualWindowIndex);
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_SETVISVALWINDOWINDEX_EXIT );
+}
+
+void GlxFullScreenView::coverFlowEventHandle( GlxCoverFlowEvent e )
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_COVERFLOWEVENTHANDLE_ENTRY );
+
+ switch( e ){
+ case TAP_EVENT :
+ activateUI();
+ break ;
+
+ //hide the ui component without animation
+ case PANNING_START_EVENT :
+ case ZOOM_START_EVENT : {
+ HbEffect::EffectStatus e;
+ mUiOff = TRUE;
+ if( mFullScreenToolBar ) {
+ /**
+ * Browsing has higer priority then playing animation of hiding tool bar
+ * so it is taking time to hide the toolbar during browsing of images
+ * so set the opacity value to 0 to immediate hide the tool bar
+ */
+ mFullScreenToolBar->setOpacity( 0 );
+ mFullScreenToolBar->hide();
+ }
+ setViewFlags( viewFlags() | HbView::ViewTitleBarHidden | HbView::ViewStatusBarHidden );
+ effectFinished( e );
+ }
+ break;
+
+ case EMPTY_ROW_EVENT :
+ emit actionTriggered( EGlxCmdEmptyData );
+ break ;
+
+ default :
+ break ;
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_COVERFLOWEVENTHANDLE_EXIT );
+}
+
+void GlxFullScreenView::effectFinished( const HbEffect::EffectStatus )
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_EFFECTFINISHED_ENTRY );
+
+ if ( mUiOffTimer == NULL ){ //view is already deactivate so no need to do any thing
+ return ;
+ }
+
+ if ( mUiOff ) {
+ mUiOffTimer->stop();
+ mCoverFlow->setUiOn(FALSE);
+ mImageStrip->hide();
+ setItemVisible( Hb::AllItems, FALSE );
+ }
+ else {
+ mUiOffTimer->start(KUiOffTime);
+ mCoverFlow->setUiOn(TRUE);
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_EFFECTFINISHED_EXIT );
+}
+
+void GlxFullScreenView::imageSelectionEffectFinished( const HbEffect::EffectStatus )
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_IMAGESELECTIONEFFECTFINISHED_ENTRY );
+
+ for ( int i = 0; i < NBR_ANIM_ITEM; i++ ) {
+ mIconItems[ i ]->resetTransform();
+ mIconItems[ i ]->setVisible( false );
+ }
+ mBackGroundItem->setVisible( false );
+
+ QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );
+ if ( variant.isValid() && variant.canConvert<int> () ) {
+ mCoverFlow->indexChanged( variant.value<int>() ) ;
+ }
+ mCoverFlow->setVisible( true );
+ mZoomWidget->setVisible( true );
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_IMAGESELECTIONEFFECTFINISHED_EXIT );
+}
+
+void GlxFullScreenView::orientChangeAnimFinished( const HbEffect::EffectStatus status )
+{
+ qDebug( "GlxFullScreenView::LsOrientChangeAnimFinished reason %d ", status.reason );
+ mIconItems[ 0 ]->resetTransform();
+ mIconItems[ 0 ]->setVisible( false );
+ mBackGroundItem->setVisible( false );
+ mCoverFlow->setVisible( true );
+ mZoomWidget->setVisible( true );
+}
+
+void GlxFullScreenView::zoomOrientChangeAnimFinished( const HbEffect::EffectStatus status )
+{
+ mZoomWidget->resetTransform();
+}
+
+void GlxFullScreenView::setLayout()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SETLAYOUT_ENTRY );
+
+ QSize sz = screenSize();
+
+ mCoverFlow->setItemSize(sz);
+ mZoomWidget->setWindowSize(sz);
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_SETLAYOUT_EXIT );
+}
+
+void GlxFullScreenView::addConnection()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_ADDCONNECTION_ENTRY );
+
+ 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() ) );
+ }
+
+ if( mCoverFlow && mZoomWidget ) {
+ connect( mZoomWidget, SIGNAL( pinchGestureReceived( int ) ), mCoverFlow, SLOT( zoomStarted( int ) ) );
+ connect( mZoomWidget, SIGNAL( zoomWidgetMovedBackground( int ) ), mCoverFlow, SLOT( zoomFinished( int ) ) );
+ connect( mCoverFlow, SIGNAL( doubleTapEventReceived( QPointF ) ), mZoomWidget, SLOT( animateZoomIn( QPointF ) ) );
+ }
+
+ connect( mWindow, SIGNAL( orientationChanged( Qt::Orientation ) ), this, SLOT( orientationChanged( Qt::Orientation ) ) );
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_ADDCONNECTION_EXIT );
+}
+
+void GlxFullScreenView::removeConnection()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_REMOVECONNECTION_ENTRY );
+
+ 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()));
+ }
+
+ if( mCoverFlow && mZoomWidget ) {
+ disconnect(mZoomWidget,SIGNAL( pinchGestureReceived(int) ), mCoverFlow, SLOT( zoomStarted(int) ) );
+ disconnect(mZoomWidget,SIGNAL( zoomWidgetMovedBackground(int) ), mCoverFlow, SLOT( zoomFinished(int) ) );
+ }
+
+ disconnect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationChanged(Qt::Orientation)));
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_REMOVECONNECTION_EXIT );
+}
+
+void GlxFullScreenView::setImageStripModel()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SETIMAGESTRIPMODEL_ENTRY );
+
+ 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) );
+ }
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_SETIMAGESTRIPMODEL_EXIT );
+}
+
+GlxFullScreenView::~GlxFullScreenView()
+{
+ OstTraceFunctionEntry0( DUP1_GLXFULLSCREENVIEW_GLXFULLSCREENVIEW_ENTRY );
+
+ cleanUp();
+ for ( int i = 0; i < NBR_ANIM_ITEM; i++ ) {
+ delete mIconItems[ i ] ;
+ }
+ delete mBackGroundItem;
+ delete mImageStrip;
+ delete mFullScreenToolBar;
+ delete mCoverFlow;
+ delete mZoomWidget;
+
+ 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" ));
+ HbEffect::remove( QString( "HbGridViewItem" ), QString( ":/data/zoomin.fxml" ), QString( "SelectHide" ) );
+ HbEffect::remove( QString( "HbGridViewItem" ), QString( ":/data/zoomout.fxml" ), QString( "SelectShow" ) );
+ HbEffect::remove( QString( "HbIconItem" ), QString( ":/data/rotatefslandscape.fxml" ), QString( "RotateFSLS" ) );
+ HbEffect::remove( QString( "HbIconItem" ), QString( ":/data/rotatefsprotrait.fxml" ), QString( "RotateFSPT" ) );
+
+ OstTraceFunctionExit0( DUP1_GLXFULLSCREENVIEW_GLXFULLSCREENVIEW_EXIT );
+}
+
+void GlxFullScreenView::initAnimationItem()
+{
+ if( mIconItems[0] == NULL ) {
+ mBackGroundItem = new HbIconItem( mImageStrip->parentItem() );
+ mBackGroundItem->setBrush( QBrush( Qt::black ) );
+ mBackGroundItem->setZValue( mImageStrip->zValue() - 3 );
+ mBackGroundItem->setPos( 0, 0 );
+ for( int i = 0; i < NBR_ANIM_ITEM; i++ ) {
+ mIconItems[ i ] = new HbIconItem( mImageStrip->parentItem() );
+ mIconItems[ i ]->setZValue( mImageStrip->zValue() - 2 );
+ mIconItems[ i ]->setPos( 0, 0 );
+ mIconItems[ i ]->setAlignment( Qt::AlignCenter );
+ }
+ }
+}
+
+void GlxFullScreenView::imageSelectionAnimation(const QModelIndex &index)
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_IMAGESELECTIONANIMATION_ENTRY );
+
+ initAnimationItem();
+ for ( int i = 0; i < NBR_ANIM_ITEM; i++ ) {
+ mIconItems[ i ]->setVisible( true );
+ mIconItems[ i ]->setSize( screenSize() );
+ }
+ mBackGroundItem->setVisible( true );
+ mBackGroundItem->setSize( screenSize() );
+
+ mIconItems[ 0 ]->setIcon( mCoverFlow->getIcon( mCoverFlow->getFocusIndex() ) );
+ mIconItems[ 1 ]->setIcon( mCoverFlow->getIcon( index.row() ) );
+ mCoverFlow->setVisible( false );
+ mZoomWidget->setVisible( false );
+
+ HbEffect::start( mIconItems[ 0 ], QString( "HbGridViewItem" ), QString( "SelectHide" ) );
+ HbEffect::start( mIconItems[ 1 ], QString( "HbGridViewItem" ), QString( "SelectShow" ), this, "imageSelectionEffectFinished" );
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_IMAGESELECTIONANIMATION_EXIT );
+}
+
+void GlxFullScreenView::cancelSelectionAnimation()
+{
+ if ( mIconItems[0] && HbEffect::effectRunning( mIconItems[1], QString( "SelectShow" ) ) ) {
+ HbEffect::cancel( mIconItems[0], QString( "SelectHide" ), false, false, true );
+ HbEffect::cancel( mIconItems[1], QString( "SelectShow" ), false, true, true );
+ }
+}
+
+void GlxFullScreenView::playOrientChangeAnim()
+{
+ qDebug("GlxFullScreenView::playOrientChangeAnim()");
+ initAnimationItem();
+ mIconItems[ 0 ]->setOpacity( 1 );
+ mIconItems[ 0 ]->setSize( screenSize() );
+ mIconItems[ 0 ]->setVisible( true );
+ mIconItems[ 0 ]->setIcon( mCoverFlow->getIcon( mCoverFlow->getFocusIndex() ) );
+
+ mBackGroundItem->setVisible( true );
+ mBackGroundItem->setSize( screenSize() );
+
+ mCoverFlow->setVisible( false );
+ mZoomWidget->setVisible( false );
+ if ( mWindow->orientation() == Qt::Horizontal ) {
+ HbEffect::start( mIconItems[0], QString( "HbIconItem" ), QString( "RotateFSLS" ), this, "orientChangeAnimFinished" );
+ }
+ else {
+ HbEffect::start( mIconItems[0], QString( "HbIconItem" ), QString( "RotateFSPT" ), this, "orientChangeAnimFinished" );
+ }
+}
+
+void GlxFullScreenView::playZoomOrientChangeAnim()
+{
+ if ( mWindow->orientation() == Qt::Horizontal ) {
+ HbEffect::start( mZoomWidget, QString( "HbIconItem" ), QString( "RotateFSLS" ), this, "zoomOrientChangeAnimFinished" );
+ }
+ else {
+ HbEffect::start( mZoomWidget, QString( "HbIconItem" ), QString( "RotateFSPT" ), this, "zoomOrientChangeAnimFinished" );
+ }
+}
+
+void GlxFullScreenView::handleToolBarAction()
+{
+ OstTraceFunctionEntry0( GLXFULLSCREENVIEW_HANDLETOOLBARACTION_ENTRY );
+
+ HbAction *action = qobject_cast<HbAction*>(sender());
+ qint32 commandId = action->data().toInt();
+ emit actionTriggered( commandId );
+
+ OstTraceFunctionExit0( GLXFULLSCREENVIEW_HANDLETOOLBARACTION_EXIT );
+}
+
+int GlxFullScreenView::getSubState()
+{
+ int substate = NO_FULLSCREEN_S;
+
+ if ( mModel ) {
+ QVariant variant = mModel->data( mModel->index(0,0), GlxSubStateRole );
+ if ( variant.isValid() && variant.canConvert<int> () ) {
+ substate = variant.value<int>();
+ }
+ }
+ return substate;
+}
+
+bool GlxFullScreenView::eventFilter(QObject *obj, QEvent *ev)
+{
+ GLX_LOG_INFO1("GlxFullScreenView::event() %d event type", ev->type());
+ if ( ev->type() == QEvent::ApplicationActivate && mTvOutWrapper) {
+ GLX_LOG_INFO("GlxFullScreenView::event() shift to native - CGlxHdmi");
+ mTvOutWrapper->setToNativeMode();
+ }
+ if (ev->type() == QEvent::ApplicationDeactivate)
+ {
+ if(mZoomWidget) {
+ mZoomWidget->forceZoomToBackground();
+ }
+ if (mTvOutWrapper) {
+ GLX_LOG_INFO("GlxFullScreenView::event() shift to Clone - CGlxHdmi");
+ mTvOutWrapper->setToCloningMode();
+ }
+ }
+ return HbView::eventFilter(obj,ev);
+}
+