1 /*

     2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    Implementation of FULL-SCREEN view

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // Avkon and System Headers 

    22 #include <eikbtgpc.h>                           // CEikButtonGroupContainer

    23 #include <aknViewAppUi.h>

    24 #include <data_caging_path_literals.hrh>        // for KDC_APP_RESOURCE_DIR

    25 #include <glxcollectionpluginimageviewer.hrh>

    26 #include <StringLoader.h>                       // String Loader

    27 #include <AknIconUtils.h>

    28 #include <e32math.h>

    29 

    30 //For animation Effects

    31 #include <akntranseffect.h>

    32 #include <akntransitionutils.h>

    33 #include <alf/alflayout.h>

    34 

    35 // Alf Headers

    36 #include <alf/ialfwidgetfactory.h>              // widget factory

    37 #include <alf/alfwidgetcontrol.h>               // To get CAlfControl from CAlfWidgetControl

    38 #include <alf/ialfviewwidget.h>                 // View Widget

    39 #include <alf/alfwidgetenvextension.h>          // Widget Env Extensions to create view widget

    40 #include <alf/alfutil.h>                        // AlfUtil

    41 

    42 // Antariksh Headers

    43 #include <mul/mulevent.h>

    44 #include <mul/imulcoverflowwidget.h>            // Coverflow widget

    45 #include <mul/imulsliderwidget.h>               // For Slider Widget

    46 #include <mpxcollectionpath.h>

    47 

    48 #include <gesturehelper.h>

    49 

    50 using namespace GestureHelper;

    51 

    52 #include <glxhdmicontroller.h>

    53 

    54 // Photos Headers

    55 #include <glxlog.h>                             // CGlxLogger

    56 #include <glxtracer.h>                          // For Log

    57 #include <glxmedialistmulmodelprovider.h>       // For MulModelProvider

    58 #include <glxcommandhandlers.hrh>               // For EGlxCmdFullScreenBack               

    59 #include <glxfullscreenviewdata.rsg>            // FS View Resource

    60 #include <glxthumbnailattributeinfo.h>          // KGlxMediaIdThumbnail

    61 #include <glxactivemedialistregistry.h>         // For medialist registry

    62 #include <glxerrormanager.h>

    63 #include <glxzoomcontrol.h>

    64 #include <glxuiutilities.rsg>

    65 #include <glxgeneraluiutilities.h>

    66 #include <glxtexturemanager.h>

    67 #include <glxicons.mbg>

    68 #include <glxsetappstate.h>

    69 #include <glxdrmutility.h>

    70 #include <glxscreenfurniture.h>

    71 #include "glxfullscreenviewimp.h"

    72 #include <glxnavigationalstate.h>

    73 #include <glxmedia.h>

    74 #include <glxnavigationalstate.h>

    75 #include <mpxcollectionpath.h>

    76 #include <glxcollectionpluginimageviewer.hrh>

    77 #include <glxuistd.h>

    78 #include "glxfullscreenbusyicon.h"

    79 

    80 using namespace Alf;

    81 

    82 const TInt KGlxScreenTimeout =10000000;

    83 const TInt KCoverflowDataWindowSize = 1;

    84 const TInt KGlxMaxSmallImageZoomLevel =150;

    85 const TInt KGlxMaxBigImageZoomLevel   =100;

    86 const TInt KGlxMinSmallImageZoomLevel =100;

    87 const TInt KGlxNeutralPinchPosition   =100;

    88 const TInt KGlxSliderTickValue        =5;

    89 const TInt KGlxRealTruncationPadding  =0.5;

    90 

    91 /**

    92  * Start Delay for the periodic timer, in microseconds

    93  */

    94 const TInt KPeriodicStartDelay = 250000; 

    95 /**

    96  * Interval delay for the periodic timer, in microseconds

    97  */

    98 const TInt KPeriodicIntervalDelay = 500000; 

    99 

   100 /** 

   101  * Fullscreen texture offset 

   102  */ 

   103 const TInt KTextureOffset = 2; 

   104 

   105 // This constant is used to calculate the index of the item 

   106 // for which texture has to removed.

   107 const TInt KFullScreenIterator = KTextureOffset + 1; 

   108 

   109 // This constant is used to calculate the maximum number of fullscreen textures 

   110 // needs to be updated during foreground event.

   111 const TInt KFullScreenTextureOffset = KFullScreenIterator + KTextureOffset;

   112 

   113 const TInt KGlxDecodingThreshold = 3000000; // pixels

   114 

   115 _LIT( KTfxResourceActivateFullScreen, "z:\\resource\\effects\\photos_fullscreen_open.fxml" );

   116 _LIT( KTfxResourceNoEffect, "");

   117 

   118 // ======== MEMBER FUNCTIONS ========

   119 

   120 // ---------------------------------------------------------------------------

   121 // C++ default constructor can NOT contain any code, that

   122 // might leave.

   123 // ---------------------------------------------------------------------------

   124 //

   125 CGlxFullScreenViewImp::CGlxFullScreenViewImp(

   126 		const TFullScreenViewResourceIds& aResourceIds, TInt aViewUID) :

   127 	iResourceIds(aResourceIds), iViewUid(aViewUID)

   128 	{

   129 	TRACER("CGlxFullScreenViewImp::CGlxFullScreenViewImp");

   130 	}

   131 

   132 // ---------------------------------------------------------------------------

   133 // Two-phased constructor.

   134 // ---------------------------------------------------------------------------

   135 //

   136 CGlxFullScreenViewImp* CGlxFullScreenViewImp::NewL(

   137 		MGlxMediaListFactory* aMediaListFactory,

   138 		const TFullScreenViewResourceIds& aResourceIds, 

   139 		TInt aViewUID,

   140 		const TDesC& aTitle)

   141 	{

   142 	TRACER("CGlxFullScreenViewImp::NewL");

   143 	CGlxFullScreenViewImp* self = CGlxFullScreenViewImp::NewLC (

   144 			aMediaListFactory, aResourceIds, aViewUID, aTitle);

   145 	CleanupStack::Pop (self);

   146 	return self;

   147 	}

   148 

   149 // ---------------------------------------------------------------------------

   150 // Two-phased constructor.

   151 // ---------------------------------------------------------------------------

   152 //

   153 CGlxFullScreenViewImp* CGlxFullScreenViewImp::NewLC(

   154 		MGlxMediaListFactory* aMediaListFactory,

   155 		const TFullScreenViewResourceIds& aResourceIds, TInt aViewUID,

   156 		const TDesC& aTitle)

   157 	{

   158 	TRACER("CGlxFullScreenViewImp::NewLC");

   159 	CGlxFullScreenViewImp* self =new (ELeave) CGlxFullScreenViewImp(aResourceIds, aViewUID);

   160 	CleanupStack::PushL (self);

   161 	self->ConstructL (aMediaListFactory, aTitle);

   162 	return self;

   163 	}

   164 

   165 // ---------------------------------------------------------------------------

   166 //  ConstructL.

   167 // ---------------------------------------------------------------------------

   168 //

   169 void  CGlxFullScreenViewImp::ConstructL(

   170 		MGlxMediaListFactory* aMediaListFactory, const TDesC& aTitle)

   171 	{

   172 	TRACER("CGlxFullScreenViewImp::ConstructL");

   173 	BaseConstructL (iResourceIds.iViewId);

   174 	ViewBaseConstructL();

   175 	MLViewBaseConstructL (aMediaListFactory, aTitle , EFalse);

   176 	

   177 	iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

   178 	//Register the view to recieve toolbar events. ViewBase handles the events

   179 	SetToolbarObserver(this);

   180 	iImgViewerMode = EFalse;

   181     //Disable the toolbar always while entering fullscreen

   182 	EnableFSToolbar(EFalse);

   183     ShowToolbarOnViewActivation(EFalse);

   184 	

   185 	//Get the ScreenFurniture instance

   186 	iScreenFurniture = iUiUtility->ScreenFurniture();

   187 	

   188     //Get the env from the uiutilities

   189 	iEnv = iUiUtility->Env ();

   190 	

   191 	iZoomButtonGroup = CEikButtonGroupContainer::NewL(

   192 	        CEikButtonGroupContainer::ECba,  // type

   193 	        CEikButtonGroupContainer::EHorizontal,  // orientation

   194 	        this,  // command observer

   195 	        R_GLX_FULLSCREEN_SOFTKEYS_ZOOM ); 

   196 	iZoomButtonGroup->MakeVisible( EFalse );

   197 

   198 	//create the drmutility instance

   199 	iDrmUtility = CGlxDRMUtility::InstanceL();

   200    // Get object that stores the active media list registry

   201     iActiveMediaListRegistry = CGlxActiveMediaListRegistry::InstanceL();

   202     

   203     iIsDialogLaunched = EFalse;

   204     iIsMMCRemoved = EFalse;

   205 	

   206 	iMMCNotifier = CGlxMMCNotifier::NewL(*this);

   207 	if(!iPeriodic)

   208 		{

   209 		iPeriodic = CPeriodic::NewL(CActive::EPriorityStandard);

   210 		}

   211 	iGlxTvOut = CGlxTv::NewL(*this);

   212 	

   213 	iNaviState = CGlxNavigationalState::InstanceL();

   214     }

   215 

   216 // ---------------------------------------------------------------------------

   217 // ~CGlxFullScreenViewImp()

   218 // ---------------------------------------------------------------------------

   219 //

   220 CGlxFullScreenViewImp::~CGlxFullScreenViewImp()

   221     {

   222     TRACER("CGlxFullScreenViewImp::~CGlxFullScreenViewImp");

   223     if(iAlfEffectObs)

   224         {

   225         delete iAlfEffectObs;

   226         }

   227     if(iMMCNotifier)

   228         {

   229         delete iMMCNotifier;

   230         iMMCNotifier = NULL;

   231         }

   232     if(iMediaListMulModelProvider)

   233         {

   234         delete iMediaListMulModelProvider;

   235         }

   236     if(iTimer)

   237         {

   238         if(iTimer->IsActive())

   239             {

   240             iTimer->Cancel();

   241             }

   242         delete iTimer;

   243         }

   244 	if(iZoomButtonGroup)

   245         {

   246         AppUi()->RemoveFromStack( iZoomButtonGroup );

   247         delete iZoomButtonGroup;

   248         }

   249 	if(iGlxTvOut)

   250         {

   251         delete iGlxTvOut;

   252         }

   253     if(iActiveMediaListRegistry)

   254         {

   255         iActiveMediaListRegistry->Close();

   256 	    }

   257     if( iDrmUtility )

   258 		{

   259 		iDrmUtility->Close();

   260 		}

   261     if (iPeriodic)

   262  		{

   263  		iPeriodic->Cancel();

   264  		delete iPeriodic;

   265  		}

   266     

   267     if (iNaviState)

   268         {

   269         iNaviState->Close();

   270         }    

   271 	}

   272  // ---------------------------------------------------------------------------

   273 // From CGlxViewBase

   274 // ---------------------------------------------------------------------------

   275 //

   276 TUid CGlxFullScreenViewImp::Id() const

   277     {

   278     TRACER("CGlxFullScreenViewImp::Id");

   279     return TUid::Uid(iViewUid);

   280 	}

   281 

   282 

   283 // ---------------------------------------------------------------------------

   284 // Destroys a coverflow widget

   285 // ---------------------------------------------------------------------------

   286 //

   287 void CGlxFullScreenViewImp::DestroyWidgets()

   288     {

   289     TRACER("CGlxFullScreenViewImp::DestroyCoverflowWidget");

   290     if (iCoverFlowWidget)

   291         {

   292         iCoverFlowWidget->RemoveEventHandler(*this);

   293         }

   294     // Destror Slider widget

   295     DestroySliderWidget();

   296     

   297     delete iMediaListMulModelProvider;

   298     iMediaListMulModelProvider = NULL;

   299 

   300     IAlfWidgetFactory& widgetFactory = AlfWidgetEnvExtension::widgetFactory(*iEnv); 

   301     // Destroying this widget calls destructor of single line meta pane

   302     widgetFactory.destroyWidget(iViewWidget);

   303 

   304     iCoverFlowWidget = NULL;

   305     iViewWidget = NULL;

   306     }

   307 

   308 // ---------------------------------------------------------------------------

   309 // Destroys a Slider widget

   310 // ---------------------------------------------------------------------------

   311 //

   312 void CGlxFullScreenViewImp::DestroySliderWidget()

   313     {

   314     TRACER("CGlxFullScreenViewImp::DestroySliderWidget");

   315     if(iSliderWidget)

   316         {

   317         iSliderWidget->RemoveEventHandler(*this);

   318         }

   319     iSliderWidget = NULL;

   320     iSliderModel = NULL;

   321     }

   322 // ---------------------------------------------------------------------------

   323 // From CAknView

   324 // Handles a view activation.

   325 // ---------------------------------------------------------------------------

   326 //

   327 void CGlxFullScreenViewImp::DoMLViewActivateL(

   328 		const TVwsViewId & /* aPrevViewId */, TUid /* aCustomMessageId */,

   329 		const TDesC8 & /* aCustomMessage */)

   330 	{

   331     TRACER("CGlxFullScreenViewImp::DoMLViewActivateL");

   332 	

   333     // hide the toolbar

   334     EnableFSToolbar(EFalse);

   335     

   336     if (iMediaList->Count() == 0)

   337         {

   338         GLX_LOG_INFO("CGlxFullScreenViewImp::DoMLViewActivateL() - No items!");	

   339 		// While in slideshow from fullscreen view,

   340         // 1) Connect USB in mass storage mode or 

   341         // 2) Delete items through file manager 

   342         // shall result in activating fullscreen view with no items; so, goto grid view.

   343         iNaviState->ActivatePreviousViewL();

   344         }

   345     else

   346         {

   347         //fix for ESLM-7YYDXC: When in FullScreen View, view mode must be 'EView'

   348         //While coming back from SlideShow to FullScreen view, need to set view mode.

   349         if (iMediaList->Count() && iNaviState->ViewingMode()

   350                 != NGlxNavigationalState::EView)

   351             {

   352             iNaviState->SetToViewMode();

   353             }

   354         }

   355 

   356     CMPXCollectionPath* collPath = iNaviState->StateLC();

   357     if (collPath->Id() == TMPXItemId(

   358             KGlxCollectionPluginImageViewerImplementationUid))

   359         {

   360         iImgViewerMode = ETrue;

   361         CreateImageViewerInstanceL();

   362         }

   363     CleanupStack::PopAndDestroy(collPath);

   364 

   365     iScrnSize = iUiUtility->DisplaySize();

   366     iGridIconSize = iUiUtility->GetGridIconSize();

   367 

   368     iHdmiWidth = (iScrnSize.iWidth > iScrnSize.iHeight ?iScrnSize.iWidth :iScrnSize.iHeight);

   369     iHdmiHeight = (iScrnSize.iWidth < iScrnSize.iHeight ?iScrnSize.iWidth :iScrnSize.iHeight);

   370 

   371     //Create hdmicontroller when it is only launched from fullscreen.  

   372     //From filemanager show only clone mode.

   373     iHdmiController = CGlxHdmiController::NewL(*this); 

   374     

   375     if( !iImgViewerMode )    

   376         {

   377         SetItemToHDMIL();

   378         }

   379     iScreenFurniture->SetActiveView(iViewUid);

   380     

   381     //set the ui state to off,when the Fullscreen launches

   382     SetUiState(EUiOff);

   383    

   384    	GlxSetAppState::SetState(EGlxInFullScreenView);

   385    	 

   386     // create the coverflow

   387     CreateCoverflowWidgetL();

   388     

   389     CreateSliderWidgetL();

   390     

   391     iBusyIcon = CGlxFullScreenBusyIcon::NewL(*iMediaList,*iUiUtility);

   392     // create a zoom control

   393     iZoomControl = CGlxZoomControl::NewL(*this, *iMediaList,

   394             *iZoomButtonGroup, *iSliderWidget, iGestureHelper);

   395 

   396     // hide the screen furniture

   397     HideUi(ETrue);

   398 	// Set active media list pointer, so that UPnP renderer knows about this list

   399     iActiveMediaListRegistry->RegisterActiveMediaList(iMediaList);

   400     

   401 	if ( !iPeriodic->IsActive() )

   402 		{

   403 	    iPeriodic->Start(KPeriodicStartDelay, KPeriodicIntervalDelay,

   404 	            TCallBack(&PeriodicCallback, static_cast<TAny*> (this)));

   405 		}

   406 		

   407 	//Set the animation effect for the coverflow widget since the animation

   408 	//does not work for both avkon and alf together. This can be done since the

   409 	//UI Screen furnitures are disabled by default while going to fullscreen.

   410 	//Check if the transitions are enabled from themes

   411     if (CAknTransitionUtils::TransitionsEnabled(

   412                                     AknTransEffect::EFullScreenTransitionsOff))

   413         {

   414         if(!iAlfEffectObs)

   415             {

   416             iAlfEffectObs = CAlfEffectObserver::NewL();

   417             }

   418         const_cast<CAlfLayout&> (iCoverFlowWidget->ContainerLayout()).SetEffectL(

   419                 KTfxResourceActivateFullScreen);

   420         iEffectHandle = iCoverFlowWidget->ContainerLayout().Identifier();

   421         iAlfEffectObs->SubscribeCallbackL(this,iEffectHandle);

   422         }

   423     

   424 	//Disable the status pane here as it causes flicker while animating

   425     CAknViewAppUi* appui = AppUi();

   426     if ( appui )

   427         {

   428         appui->StatusPane()->MakeVisible(EFalse);

   429         appui->Cba()->MakeVisible(EFalse);

   430         }

   431 

   432 	iViewWidget->show(true);    

   433 	}

   434 	

   435 

   436 // ---------------------------------------------------------------------------

   437 // Creates a coverflow widget

   438 // ---------------------------------------------------------------------------

   439 //

   440 void CGlxFullScreenViewImp::CreateCoverflowWidgetL()

   441     {

   442     TRACER("CGlxFullScreenViewImp::CreateCoverflowWidgetL");

   443 

   444     const char* KWidgetName("mulcoverflowwidget");

   445     const char* KCoverflowViewWidget("CoverflowViewWidget");

   446     const char* KCoverflowWidget("CoverflowWidget");

   447     try

   448         {

   449         // Get widget factory from CAlfEnv

   450         // Factory is then used to create the individual widgets & data model

   451 

   452         IAlfWidgetFactory& widgetFactory =

   453                 AlfWidgetEnvExtension::widgetFactory(*iEnv);

   454 

   455         // create a view widget  

   456         iViewWidget = widgetFactory.createViewWidget(KCoverflowViewWidget,

   457                 0x113);

   458         // hide control and status pane

   459         iViewWidget->enableControlPane(EFalse);

   460         iViewWidget->enableStatusPane(EFalse);

   461         iViewWidget->setRect(TRect(TPoint(0, 0), AlfUtil::ScreenSize()));

   462         // create coverflow widget

   463         iCoverFlowWidget = widgetFactory.createWidget<IMulCoverFlowWidget> (

   464                 KWidgetName, KCoverflowWidget, *iViewWidget, NULL);

   465         iCoverFlowWidget->SetFlags(IMulMultiItemWidget::EMulWidgetDoubleTap);

   466 

   467         // Widget takes the ownership

   468         iCoverFlowWidget->AddEventHandler(*this);

   469 

   470         iCoverFlowWidget->control()->AcquireFocus();

   471         iMediaListMulModelProvider = CGlxMediaListMulModelProvider::NewL(

   472                 *iEnv, *iCoverFlowWidget, *iMediaList, iFullScreenBindingSet,

   473                 mulwidget::KTemplate4, KCoverflowDataWindowSize);

   474 

   475         iGestureHelper

   476                 = (GestureHelper::CGestureHelper*) iCoverFlowWidget->Gesturehelper();

   477         }

   478     catch(...)

   479         {

   480         User::Leave(KErrGeneral);

   481         }

   482 

   483     }

   484 

   485 //----------------------------------------------------------------------------

   486 //Initialise the slider widget and the slider model

   487 //----------------------------------------------------------------------------

   488 //

   489 void CGlxFullScreenViewImp::CreateSliderWidgetL()

   490     {

   491     const char* KSliderWidgetName("mulsliderwidget");

   492     const char* KZoomSliderWidget("ZoomSliderWidget");

   493 

   494     try

   495         {

   496         IAlfWidgetFactory& widgetFactory = AlfWidgetEnvExtension::widgetFactory(*iEnv);

   497     

   498         iSliderWidget = widgetFactory.createWidget<IMulSliderWidget>( KSliderWidgetName, 

   499                 KZoomSliderWidget, *iViewWidget, NULL);

   500     

   501         iSliderWidget->AddEventHandler(*this);

   502         iSliderWidget->SetHandleKeyEvent(EFalse);

   503         iSliderModel = widgetFactory.createModel<IMulSliderModel> ("mulslidermodel");

   504         iSliderModel->SetTemplate(ESliderTemplate3);

   505         iSliderWidget->setModel(iSliderModel);

   506         iSliderWidget->control()->disableState(IAlfWidgetControl::Focusable);

   507     

   508         //adding the range and slider tick value 

   509         if(iSliderModel)

   510             {

   511             iSliderModel->SetTick(KGlxSliderTickValue);

   512             }

   513         }

   514     catch(...)

   515         {

   516         User::Leave(KErrGeneral);

   517         }

   518     }

   519 

   520 // ---------------------------------------------------------------------------

   521 // ShowUiL

   522 // ---------------------------------------------------------------------------

   523 //	

   524 void  CGlxFullScreenViewImp::ShowUiL(TBool aStartTimer)

   525     {

   526     TRACER("CGlxFullScreenViewImp::ShowUiL");

   527 	if(CheckIfSliderToBeShownL())

   528         {

   529         //To set the Slider values.

   530         SetSliderToMin();

   531         //show the slider

   532         iSliderWidget->ShowWidget(ETrue);

   533         }

   534     else

   535         {

   536         //hide slider if UI is needed to be on and HDMI is Connected

   537         iSliderWidget->ShowWidget(EFalse);

   538         }

   539     

   540     if (iCoverFlowWidget)

   541         {

   542 		// This is done to set the item counter

   543         iCoverFlowWidget->SetUIMode(ETrue);

   544         }

   545 

   546     //Since the toolbar should not be present for ImageViewer.

   547     if(!iImgViewerMode)

   548         {

   549         //show the toolbar

   550         EnableFSToolbar(ETrue);

   551         }

   552      

   553     // For floating toolbar in non-touch devices

   554     iScreenFurniture->SetToolbarVisibility(ETrue);

   555     

   556     //show the softkeys

   557     CEikButtonGroupContainer* cba = Cba();

   558     cba->SetCommandSetL( R_GLX_FULLSCREEN_SOFTKEYS );

   559     cba->MakeVisible( ETrue );

   560     cba->DrawNow();

   561 

   562     //set the ui state to On

   563     SetUiState(EUiOn);

   564     

   565     //start the timer,for the screen timeout

   566     iTimer->Cancel();

   567     if(aStartTimer)

   568         {

   569         iTimer->Start(KGlxScreenTimeout,KGlxScreenTimeout,TCallBack( TimeOut,this ));

   570         }

   571     }

   572     

   573 // ---------------------------------------------------------------------------

   574 // HideUi

   575 // ---------------------------------------------------------------------------

   576 //	

   577 void  CGlxFullScreenViewImp::HideUi(TBool aHideSlider)

   578     {

   579     TRACER("CGlxFullScreenViewImp::HideUi");

   580     //cancel the timer

   581     iTimer->Cancel();

   582 

   583     // For floating toolbar in non-touch devices

   584     iScreenFurniture->SetToolbarVisibility(EFalse);

   585     

   586     // hide/show the slider

   587     if(iSliderWidget) 

   588         {

   589         iSliderWidget->ShowWidget(!aHideSlider);        

   590         }

   591 

   592     if (iCoverFlowWidget)

   593         {

   594         iCoverFlowWidget->SetUIMode(EFalse);

   595         }

   596     

   597     //Since the toolbar should not be present for ImageViewer.

   598     if(!iImgViewerMode)

   599         {

   600         // hide the toolbar

   601         CAknToolbar* toolbar = Toolbar();

   602         if(toolbar)

   603             {

   604             toolbar->SetToolbarVisibility(EFalse); 

   605             }

   606         }

   607     

   608     // hide the softkeys

   609     Cba()->MakeVisible( EFalse );

   610     Cba()->DrawNow();

   611  

   612     // set the ui state to On

   613     SetUiState(EUiOff);

   614     }

   615 

   616 // ---------------------------------------------------------------------------

   617 // SetUiState

   618 // ---------------------------------------------------------------------------

   619 //	

   620 void CGlxFullScreenViewImp::SetUiState (TUiState  aState)

   621     {

   622     TRACER("CGlxFullScreenViewImp::SetUiState");

   623     iUiState = aState;

   624     }

   625 

   626 // ---------------------------------------------------------------------------

   627 // GetUiState

   628 // ---------------------------------------------------------------------------

   629 //	

   630 TUiState CGlxFullScreenViewImp::GetUiState()    

   631     {

   632     TRACER("CGlxFullScreenViewImp::GetUiState");

   633     return iUiState;

   634     }

   635 

   636 // ---------------------------------------------------------------------------

   637 // TimeOut

   638 // ---------------------------------------------------------------------------

   639 //	

   640 TInt CGlxFullScreenViewImp::TimeOut(TAny* aSelf)

   641     {

   642     TRACER("CGlxFullScreenViewImp::TimeOut");

   643     if(aSelf)

   644         {

   645         CGlxFullScreenViewImp* self = static_cast <CGlxFullScreenViewImp*> (aSelf);

   646         if (self)

   647             {

   648             if ( EUiOn == self->GetUiState())

   649                 {

   650                 // After time out, hide UI only when menu is not being displayed.

   651                 if( self->MenuBar() && !(self->MenuBar()->IsDisplayed()) )

   652                     {

   653 		            self->HideUi(ETrue);

   654 					}

   655                 }

   656             }            

   657         }

   658     return KErrNone;

   659     }

   660 

   661 // ---------------------------------------------------------------------------

   662 //DeactivateFullScreen function.

   663 // ---------------------------------------------------------------------------

   664 //

   665 void  CGlxFullScreenViewImp::DeactivateFullScreen()

   666     {

   667     TRACER("CGlxFullScreenViewImp::DeactivateFullScreen");

   668     if (iCoverFlowWidget)

   669         {

   670         iCoverFlowWidget->RemoveEventHandler(*this);

   671         iCoverFlowWidget->ShowWidget(EFalse);

   672         }

   673     if(iSliderWidget)

   674         {

   675         iSliderWidget->RemoveEventHandler(*this);

   676     

   677         //show/hide the slider based on the return value of

   678         //IsHidden()

   679 	    if(iZoomControl->Activated())

   680 	        {

   681 	        HideUi(iSliderWidget->IsHidden());

   682 	        }

   683 		}

   684     }

   685 

   686 // ---------------------------------------------------------------------------

   687 //ActivateFullScreen function.

   688 // ---------------------------------------------------------------------------

   689 //

   690 void CGlxFullScreenViewImp::ActivateFullScreenL()

   691     {

   692     TRACER("CGlxFullScreenViewImp::ActivateFullScreenL");

   693     

   694      if (iCoverFlowWidget)

   695         {

   696         iCoverFlowWidget->AddEventHandler(*this);

   697         iCoverFlowWidget->ShowWidget(ETrue);

   698         }

   699     if(iSliderWidget)

   700         {

   701         iSliderWidget->AddEventHandler(*this);

   702         }

   703     iViewWidget->setRect(TRect(TPoint(0,0),AlfUtil::ScreenSize()));

   704 	GlxSetAppState::SetState(EGlxInFullScreenView);   

   705     }

   706 

   707 // ---------------------------------------------------------------------------

   708 //ActivateZoomControl function.

   709 // ---------------------------------------------------------------------------

   710 //

   711 void CGlxFullScreenViewImp::ActivateZoomControlL(TZoomStartMode aStartMode, TPoint* apZoomFocus)

   712     {

   713     TRACER("CGlxFullScreenViewImp::ActivateZoomControlL");

   714     /*

   715      * We will not do any zoom while HDMI is connected.

   716      * This is as part of HDMI improvements.

   717      */

   718     if (iHdmiController && iHdmiController->IsHDMIConnected())

   719         {

   720         // Hide zoom slider in HDMI mode as Zoom is disable.

   721         // Let the other screen furnitures intact.

   722         iSliderWidget->ShowWidget( EFalse);

   723         return;

   724         }

   725     TInt focus = iMediaList->FocusIndex();

   726     TGlxMedia item = iMediaList->Item( focus );

   727     TInt error = GlxErrorManager::HasAttributeErrorL(item.Properties() , KGlxMediaIdThumbnail);

   728    

   729     // Check if DRM rights expired for a specific media item 

   730     TBool isDrmRightsValid = ETrue;

   731     if(item.IsDrmProtected())

   732     	{

   733         if (iImgViewerMode && iImageViewerInstance->IsPrivate())

   734             {

   735             isDrmRightsValid = iDrmUtility->DisplayItemRightsCheckL(

   736                     iImageViewerInstance->ImageFileHandle(), (item.Category()

   737                             == EMPXImage));

   738             }

   739         else

   740             {

   741             //Since it is always for the focused item - use DisplayItemRightsCheckL 

   742             //instead of ItemRightsValidityCheckL

   743             isDrmRightsValid = iDrmUtility->DisplayItemRightsCheckL(

   744                     item.Uri(), (item.Category() == EMPXImage));

   745             }

   746         }

   747     // Activate Zoom if the item is an image and its DRM rights is not expired

   748     if(KErrNone == error && (EMPXImage == item.Category()) && isDrmRightsValid)

   749         {

   750         if(iZoomControl && !iZoomControl->Activated())

   751             {

   752             if(iHdmiController)

   753                 {

   754                 TBool autoZoomOut = ETrue;

   755                 //Set autozoomout to false in pinch zoom, since we would be 

   756                 //zooming out on deactivate once we get the release event.

   757                 if(aStartMode == EZoomStartPinch)                    

   758                     {

   759                     autoZoomOut = EFalse; 

   760                     }

   761                 

   762                 iHdmiController->ActivateZoom(autoZoomOut);

   763                 }

   764             

   765             GLX_LOG_INFO1("ActivateZoomControlL: Slider MaxRange = %d   ", iSliderModel->MaxRange() );

   766             GLX_LOG_INFO1("ActivateZoomControlL: Slider MinRange = %d   ", iSliderModel->MinRange() );

   767             GLX_LOG_INFO1("ActivateZoomControlL: Slider PrimaryValue= %d", iSliderModel->PrimaryValue() );

   768             

   769             if (aStartMode == EZoomStartSlider) 

   770                 {

   771                 iZoomControl->ActivateL(iSliderModel->PrimaryValue(),aStartMode, focus,

   772                                         item, apZoomFocus,iImgViewerMode);

   773                 }

   774             else 

   775                 {

   776                 iZoomControl->ActivateL(GetInitialZoomLevel(),aStartMode, focus,

   777                                         item, apZoomFocus,iImgViewerMode);

   778                 }

   779             // Now to remove all textures other than the one we are focussing on.  

   780             TInt frameCount = KErrNone;

   781             item.GetFrameCount(frameCount);

   782             // If .gif file, then only call stopanimation

   783 			if (frameCount > 1)

   784                 {

   785                 iUiUtility->GlxTextureManager().AnimateMediaItem(

   786                         item.Id(), EFalse);

   787                 }

   788             TInt count = iMediaList->Count();

   789             while (count > 0)

   790                 {

   791                 TGlxMedia mediaItem = iMediaList->Item(count-1);	

   792                 if (mediaItem.Id() != item.Id() )

   793                     {

   794                     iUiUtility->GlxTextureManager().RemoveTexture(mediaItem.Id(),EFalse);

   795                     }

   796                 count--;

   797                 }

   798             }

   799         else

   800             {

   801             return;

   802             }

   803         DeactivateFullScreen();

   804         GlxSetAppState::SetState(EGlxInZoomedView);

   805         }

   806     }

   807 

   808 // ---------------------------------------------------------------------------

   809 //DeactivateZoomControl function.

   810 // ---------------------------------------------------------------------------

   811 //

   812 void CGlxFullScreenViewImp::DeactivateZoomControlL()

   813     {

   814     TRACER("CGlxFullScreenViewImp::DeactivateZoomControlL");

   815     ActivateFullScreenL();

   816     UpdateItems();

   817     //Deactivate HDMI controller for zoom out while pinch zooming.

   818     if(iHdmiController)

   819         {

   820         iHdmiController->DeactivateZoom();

   821         }

   822     if(iZoomControl->Activated())

   823         {        

   824         iZoomControl->Deactivate();

   825         }

   826     if (iMediaList->FocusIndex() != KErrNotFound)

   827         {

   828         TGlxMedia item = iMediaList->Item(iMediaList->FocusIndex());

   829         TInt frameCount = KErrNone;

   830         item.GetFrameCount(frameCount);

   831 		// If .gif file, then only call start animation

   832         if (frameCount > 1)

   833             {

   834             iUiUtility->GlxTextureManager().AnimateMediaItem(

   835                     item.Id(), ETrue);

   836             }

   837         }

   838     

   839     SetSliderToMin();

   840     //check if the slider is already visible in zoom view.

   841     //if yes then do not disable the slider.

   842     TBool sliderInvisible = ETrue;

   843     if (EUiOn == iZoomControl->ZoomUiState())

   844         {

   845         sliderInvisible = EFalse;

   846         }

   847     

   848     HideUi(sliderInvisible);

   849     

   850     if (!sliderInvisible)

   851         {

   852         //Set the UI State to On Explicitly since the slider is ON and we have

   853         //to disable on timeout. The timer is already cancelled in HideUi().

   854         SetUiState(EUiOn);

   855         iTimer->Start(KGlxScreenTimeout,KGlxScreenTimeout,TCallBack( TimeOut,this ));

   856         }

   857     }

   858 

   859 // ---------------------------------------------------------------------------

   860 // From CAknView

   861 // View deactivation function.

   862 // ---------------------------------------------------------------------------

   863 //

   864 void CGlxFullScreenViewImp::DoMLViewDeactivate()

   865     {

   866     TRACER("CGlxFullScreenViewImp::DoMLViewDeactivate");

   867 	//Disabling the toolbar here since it would give a crash when

   868 	//we try to enable the toolbar in activate without exiting photos.

   869     if(!iImgViewerMode)

   870         {    

   871         // hide the toolbar

   872         EnableFSToolbar(EFalse);

   873         

   874         //Setting Soft key to EmptySoftKeys would cause crash

   875 		//When Fullscreen is opened from ImageViewer.

   876         //And also, when Photos exits from FullScreen View.

   877         //So Set Soft Keys to empty only when not in Image Viewer mode 

   878         //& Photos is not exiting.

   879 		if( !iUiUtility->IsExitingState() )

   880 			{

   881 			CEikButtonGroupContainer* cba = Cba();

   882 			TRAP_IGNORE( cba->SetCommandSetL( R_GLX_FULLSCREEN_EMPTYSOFTKEYS ) );

   883 			cba->DrawNow();

   884 			}

   885         }

   886 	else

   887 		{

   888 		DeleteImageViewerInstance();

   889 		}

   890     

   891     HideUi(ETrue); 

   892 	// In Order to hide the softkeys immediately. The above statement does not do that as soon as we need. 

   893 	// So we do the below trick. The SK overlap is still there but much much less noticable. 

   894     CCoeEnv::Static()->WsSession().Flush(); 

   895 

   896     //Clear the last uri for which DRM Rights were consumed before going back to grid view

   897     //since the GridView::Activate() and FullScreen::DeActivate() can be called in any order,

   898     //this call is being made to be on safer side

   899     iDrmUtility->ClearLastConsumedItemUriL();

   900     iScreenFurniture->ViewDeactivated(iViewUid);

   901     iImgViewerMode = EFalse;

   902     if (iHdmiController)

   903         {

   904         delete iHdmiController;

   905         iHdmiController = NULL;

   906         }

   907     

   908     if(iZoomControl)

   909         {

   910         if(iZoomControl->Activated())

   911             {

   912             iZoomControl->Deactivate();

   913             }

   914         delete iZoomControl;

   915         iZoomControl = NULL;

   916         } 

   917     DestroyWidgets();

   918     iTimer->Cancel();

   919 	// Deregister active media list pointer

   920     iActiveMediaListRegistry->DeregisterActiveMediaList(iMediaList);

   921     

   922     /*

   923      * safe code-- if user press back very quickly

   924      * cancelling the timer while going back to prev view

   925      */

   926     if (iPeriodic->IsActive())

   927  		{

   928  		iPeriodic->Cancel();

   929  		}

   930 

   931     }      

   932 // ---------------------------------------------------------------------------

   933 // Foreground event handling function.

   934 // ---------------------------------------------------------------------------

   935 //

   936 void CGlxFullScreenViewImp::HandleForegroundEventL(TBool aForeground)

   937     {

   938     TRACER("CGlxFullScreenViewImp::HandleForegroundEventL");

   939     CAknView::HandleForegroundEventL(aForeground);

   940 

   941     iUiUtility->SetForegroundStatus(aForeground);

   942 

   943     if(iMMCState)

   944         {

   945         iMMCState =EFalse;

   946         NavigateToMainListL();

   947         }

   948     

   949     if(iZoomControl && iZoomControl->Activated())

   950         {

   951         iZoomControl->HandleZoomForegroundEvent(aForeground);

   952         }

   953 

   954     if (!aForeground)

   955         {

   956         if(iHdmiController)

   957 			{   

   958             iHdmiController->ShiftToCloningMode();

   959 			}

   960 		iUiUtility->GlxTextureManager().FlushTextures();

   961 		}

   962 	else

   963 		{

   964 		if (iMediaList)

   965 			{

   966 			/** if there is no image to show go back to the previous view */

   967 			if (!iMediaList->Count() && iNaviState->ViewingMode()

   968                     == NGlxNavigationalState::EView)

   969                 {

   970                 iUiUtility->SetViewNavigationDirection(

   971                         EGlxNavigationBackwards);

   972                 iNaviState->ActivatePreviousViewL();

   973                 }

   974 			else if (iMediaListMulModelProvider)

   975 				{

   976 	            UpdateItems();

   977 

   978 				if (iHdmiController)

   979 					{

   980 					iHdmiController->ShiftToPostingMode();

   981 					}

   982 				}

   983             }

   984         }

   985     }

   986 

   987 

   988 // ---------------------------------------------------------------------------

   989 // From IAlfWidgetEventHandler..

   990 // ---------------------------------------------------------------------------

   991 //

   992 bool CGlxFullScreenViewImp::accept( CAlfWidgetControl& /*aControl*/,

   993 		const TAlfEvent& /*aEvent*/) const

   994     {

   995     TRACER("CGlxFullScreenViewImp::accept()");

   996     return ETrue;

   997     }

   998 

   999 // ---------------------------------------------------------------------------

  1000 // From IAlfWidgetEventHandler..

  1001 // ---------------------------------------------------------------------------

  1002 //

  1003 AlfEventStatus CGlxFullScreenViewImp::offerEvent(

  1004 		CAlfWidgetControl& /*aControl*/, const TAlfEvent& aEvent)

  1005     {

  1006     TRACER("CGlxFullScreenViewImp::offerEvent");

  1007     // The below function call will not add any values except

  1008     // to reduce the codescanner warnings to one

  1009     return OfferEventL(aEvent);

  1010     }

  1011 

  1012 // ---------------------------------------------------------------------------

  1013 // OfferEventL()

  1014 // ---------------------------------------------------------------------------

  1015 //

  1016 AlfEventStatus CGlxFullScreenViewImp::OfferEventL(const TAlfEvent& aEvent)

  1017     {

  1018     TRACER("CGlxFullScreenViewImp::offerEventL");

  1019     if ( aEvent.IsKeyEvent())

  1020         {

  1021         switch ( aEvent.KeyEvent().iScanCode )

  1022             {

  1023             case EStdKeyNkpAsterisk :

  1024 				if(iUiUtility->IsPenSupported())

  1025 					{

  1026 					return EEventNotHandled;

  1027 					}

  1028             case EStdKeyIncVolume :

  1029                 //Listen EStdKeyApplicationD as EKeyZoomIn key is mapped to TKeyCode:: 

  1030                 //EKeyApplicationC for which TStdScancode is EStdKeyApplicatoinC

  1031             case EStdKeyApplicationC: 

  1032                 {

  1033                 if(EEventKeyDown == aEvent.Code())

  1034                     {

  1035                     HideUi(EFalse);

  1036                     TRAP_IGNORE( ActivateZoomControlL(EZoomStartKey));

  1037                     return EEventConsumed;

  1038                     }

  1039                 }

  1040             case EStdKeyUpArrow:            

  1041             case EStdKeyDownArrow:

  1042             case EStdKeyDevice0:

  1043             case EStdKeyDevice1:

  1044                 //Listen EStdKeyApplicationC as EKeyZoomOut key is mapped to TKeyCode:: 

  1045                 //EKeyApplicationD for which TStdScancode is EStdKeyApplicatoinD 

  1046             case EStdKeyApplicationD: 

  1047                 {

  1048                 if ( EUiOff == GetUiState()&& (

  1049                         aEvent.Code() == EEventKey ) )

  1050                     {

  1051                     //the Ui timer should be started once the UI screen furniture is shown

  1052                     ShowUiL(ETrue);

  1053                     } 

  1054                 return EEventHandled;              

  1055                 }

  1056             case EStdKeyLeftArrow:

  1057             case EStdKeyRightArrow:

  1058                 {

  1059                 if ( EUiOn == GetUiState() )                    

  1060                     {

  1061                     HideUi(ETrue);

  1062                     }

  1063                 return EEventHandled;

  1064                 }

  1065 			case EStdKeyApplication1C:

  1066            		{

  1067 				if(iUiUtility->IsPenSupported())

  1068 					{

  1069 					return EEventNotHandled;

  1070 					}

  1071 				else

  1072 					{

  1073 					ProcessCommandL(KGlxCmdMnShowMap);

  1074                     return EEventHandled;  				

  1075 					}

  1076 				}

  1077             default:

  1078                 return EEventNotHandled;

  1079             }

  1080         }

  1081     if(!aEvent.IsCustomEvent())

  1082         {   

  1083         GLX_LOG_INFO("Event Not Handled");          

  1084         return EEventNotHandled;

  1085         }

  1086 

  1087     if(aEvent.IsCustomEvent())

  1088         {

  1089         TInt eventId = aEvent.CustomParameter();

  1090         

  1091         switch(eventId)

  1092             {   

  1093             case KAlfActionIdDeviceLayoutChanged:

  1094                  {

  1095                  iViewWidget->setRect(TRect(TPoint(0,0),AlfUtil::ScreenSize()));

  1096                  

  1097                  iScreenFurniture->SetToolbarPosition();

  1098                                   

  1099                  return EEventNotHandled;

  1100                  }

  1101             case ETypeSelect:

  1102                 {

  1103                 TBool pensupport = iUiUtility->IsPenSupported();

  1104                 if ( pensupport )

  1105                     {

  1106                     if ( EUiOn == GetUiState() )                    

  1107                         {

  1108                         //Hide the slider 

  1109                         HideUi(ETrue);

  1110                         }

  1111                     else 

  1112                         {

  1113                         //the Ui timer should be started once the UI screen furniture is shown

  1114                         ShowUiL(ETrue);

  1115                         }

  1116                     }

  1117                 else

  1118                     {

  1119                     if ( EUiOff == GetUiState() )                    

  1120                         {

  1121                         //the Ui timer should be started once the UI screen furniture is shown

  1122                         ShowUiL(ETrue);

  1123                         }

  1124                     }

  1125                 }

  1126                 break;

  1127                 

  1128             case ETypeRemove:

  1129                 {

  1130                 // If From photos, delete the img.

  1131                 // If Image-Viewer collection and not in private Path 

  1132                 // handle the "C" or BackSpace key to delete the item

  1133                 if (!iImgViewerMode || (iImageViewerInstance

  1134                         && !iImageViewerInstance->IsPrivate()))