FCL/sf/app/photos: comparison photosgallery/viewframework/views/fullscreenview/src/glxfullscreenviewimp.cpp

equal deleted inserted replaced

-:2dac0fdba72b
+:191387a8b767
 #include <eikbtgpc.h>                           // CEikButtonGroupContainer
 #include <aknViewAppUi.h>
 #include <data_caging_path_literals.hrh>        // for KDC_APP_RESOURCE_DIR
 #include <glxcollectionpluginimageviewer.hrh>
 #include <StringLoader.h>                       // String Loader
+#include <AknIconUtils.h>
+#include <e32math.h>
 //For animation Effects
 #include <akntranseffect.h>
 #include <akntransitionutils.h>
 #include <alf/alflayout.h>
 #include <glxnavigationalstate.h>
 #include <glxmedia.h>
 #include <glxnavigationalstate.h>
 #include <mpxcollectionpath.h>
 #include <glxcollectionpluginimageviewer.hrh>
+#include <glxuistd.h>
 #include "glxfullscreenbusyicon.h"
 using namespace Alf;
 const TInt KGlxScreenTimeout =10000000;
 */
 const TInt KPeriodicStartDelay = 250000;
 /**
 * Interval delay for the periodic timer, in microseconds
 */
-const TInt KPeriodicIntervalDelay = 100000;
+const TInt KPeriodicIntervalDelay = 500000;
 //This constant is used to calculate the index of the item for which texture has to removed.
 //6 = 5(iterator value in forward or backward direction for fullscreen) + 1(focus index)
 const TInt KFullScreenIterator = 3;
 //Constant which says maximum number of fullscreen textures that we have have at a time.
 //11 = (5(5 fullscreen texture backwards)+1(fucus index texture)+5(5 fullscreen texture forwards))
 const TInt KFullScreenTextureOffset = 5;
+const TInt KGlxDecodingThreshold = 3000000; // pixels
 _LIT( KTfxResourceActivateFullScreen, "z:\\resource\\effects\\photos_fullscreen_open.fxml" );
 // ======== MEMBER FUNCTIONS ========
 	//create the drmutility instance
 	iDrmUtility = CGlxDRMUtility::InstanceL();
 // Get object that stores the active media list registry
 iActiveMediaListRegistry = CGlxActiveMediaListRegistry::InstanceL();
+iIsDialogLaunched = EFalse;
+iIsMMCRemoved = EFalse;
 	iMMCNotifier = CGlxMMCNotifier::NewL(*this);
 	if(!iPeriodic)
 		{
 		iPeriodic = CPeriodic::NewL(CActive::EPriorityStandard);
 }
 //destroy and close navistate and navipath
 CleanupStack::PopAndDestroy( naviState );
 CleanupStack::PopAndDestroy( navigationalState );
+iScrnSize = iUiUtility->DisplaySize();
+iGridIconSize = iUiUtility->GetGridIconSize();
 //Create hdmicontroller when it is only launched from fullscreen.
 //From filemanager show only clone mode.
 if( !iImgViewerMode )
 {
 iHdmiController = CGlxHdmiController::NewL();
 autoZoomOut = EFalse;
 }
 iHdmiController->ActivateZoom(autoZoomOut);
 }
-iZoomControl->ActivateL(GetInitialZoomLevel(),aStartMode, focus,
+if (aStartMode == EZoomStartSlider)
+{
+iZoomControl->ActivateL(iSliderModel->PrimaryValue(),aStartMode, focus,
 item, apZoomFocus,iImgViewerMode);
+}
+else
+{
+iZoomControl->ActivateL(GetInitialZoomLevel(),aStartMode, focus,
+item, apZoomFocus,iImgViewerMode);
+}
 // Now to remove all textures other than the one we are focussing on.
 TInt count = iMediaList->Count();
 while (count > 0)
 {
 TGlxMedia mediaItem = iMediaList->Item(count-1);
 SetItemToHDMIL();
 if ( NGlxNFullScreenUIState::EUiOn == GetUiSate() )
 {
 HideUi(ETrue);
 }
-TRAP_IGNORE(ShowDrmExpiaryNoteL());
+TRAP_IGNORE(ShowDrmExpiryNoteL());
 return EEventConsumed;
 }
 case EVideoIconSelect:
 {
 TGlxMedia item = iMediaList->Item( iMediaList->FocusIndex() );
 	switch (aCommand)
 		{
 		case EGlxCmdResetView:
 		    {
 		    HideUi(ETrue);
+		    if (iIsDialogLaunched && iIsMMCRemoved)
+		        {
+ProcessCommandL(EAknSoftkeyExit);
+		        }
 		    consumed = ETrue;
+		    iIsDialogLaunched = EFalse;
 		    break;
 		    }
 		case EGlxCmdFullScreenBack:
 		    SetSliderLevel();
 		    DeactivateZoomControlL();
 		    {
 SetItemToHDMIL();
 			consumed = ETrue;
 break;
 }
+		case EGlxCmdDialogLaunched:
+{
+iIsDialogLaunched = ETrue;
+break;
+}
 }
 return consumed;
 }
 // ---------------------------------------------------------------------------
 TInt focus     = iMediaList->FocusIndex();
 TGlxMedia item = iMediaList->Item( focus );
 TSize size;
 TUint8 initialZoomLevel;
 item.GetDimensions( size );
+if (KGlxDecodingThreshold < (size.iWidth * size.iHeight))
+{
+TReal areaRatio = TReal(size.iWidth*size.iHeight)/KGlxDecodingThreshold ;
+TReal sideRatio;
+Math::Sqrt(sideRatio, areaRatio);
+size.iHeight = size.iHeight /  sideRatio ;
+size.iWidth  = size.iWidth  /  sideRatio ;
+}
 TRect rect = AlfUtil::ScreenSize();
 if( rect.Width()>= size.iWidth && rect.Height() >= size.iHeight)
 {
 //if Both the Width and Height are lesser than the screen size,the initial Zoom Level will be 100
 // -----------------------------------------------------------------------------
 //
 inline void CGlxFullScreenViewImp::CallPeriodicCallback()
 {
 TRACER("CGlxFullScreenViewImp::CallPeriodicCallback");
-TRAP_IGNORE(ShowDrmExpiaryNoteL());
+TRAP_IGNORE(ShowDrmExpiryNoteL());
 }
 // ---------------------------------------------------------------------------
 // Shows expiry note / Consumes DRM rights for expired DRM files
 // ---------------------------------------------------------------------------
 //
-void CGlxFullScreenViewImp::ShowDrmExpiaryNoteL()
+void CGlxFullScreenViewImp::ShowDrmExpiryNoteL()
 	{
-TRACER("CGlxFullScreenViewImp::ShowDrmExpiaryNoteL");
+TRACER("CGlxFullScreenViewImp::ShowDrmExpiryNoteL");
 if (iMediaList->Count() > 0)
 {
 const TGlxMedia& media = iMediaList->Item(iMediaList->FocusIndex());
 TInt tnError = GlxErrorManager::HasAttributeErrorL(
 media.Properties(), KGlxMediaIdThumbnail);
-GLX_LOG_INFO1("CGlxFullScreenViewImp::ShowDrmExpiaryNoteL()"
+GLX_LOG_INFO1("CGlxFullScreenViewImp::ShowDrmExpiryNoteL()"
 " tnError=%d ", tnError);
 if (media.IsDrmProtected())
 {
-GLX_LOG_INFO("CGlxFullScreenViewImp::ShowDrmExpiaryNoteL()"
+GLX_LOG_INFO("CGlxFullScreenViewImp::ShowDrmExpiryNoteL()"
 "- ConsumeDRMRightsL()");
+//Consume DRM Rights & cancel Periodic timer for DRM images
+//only if Quality TN is available
 ConsumeDRMRightsL(media);
 }
+else
-if (tnError == KErrNone)
+{
-{
+//Cancel the periodic timer if quality thumbnail is available
-if (iPeriodic->IsActive())
+//and no error in fetching quality thumbnail.
-{
+TSize tnSize = iUiUtility->DisplaySize();
-iPeriodic->Cancel();
+TMPXAttribute qtyTnAttrib = TMPXAttribute(KGlxMediaIdThumbnail,
-}
+GlxFullThumbnailAttributeId(ETrue, tnSize.iWidth,
-}
+tnSize.iHeight));
+const CGlxThumbnailAttribute* qtyTn = media.ThumbnailAttribute(
+qtyTnAttrib);
+if (qtyTn && tnError == KErrNone)
+{
+if (iPeriodic->IsActive())
+{
+iPeriodic->Cancel();
+}
+}
+}
+//check if any Error message is to be displayed
 TMPXGeneralCategory cat = media.Category();
 TBool checkViewRights = (cat == EMPXImage);
 if (iDrmUtility->ItemRightsValidityCheckL(media.Uri(),
 checkViewRights) && tnError != KErrNone)
 {
 CleanupClosePushL(*navigationalState);
 CMPXCollectionPath* naviState = navigationalState->StateLC();
 if (naviState->Id() == TMPXItemId(
 KGlxCollectionPluginImageViewerImplementationUid))
 {
-GLX_LOG_INFO("CGlxFullScreenViewImp::ShowDrmExpiaryNoteL()"
+GLX_LOG_INFO("CGlxFullScreenViewImp::ShowDrmExpiryNoteL()"
 "- ShowErrorNoteL()");
 GlxGeneralUiUtilities::ShowErrorNoteL(tnError);
 }
 CleanupStack::PopAndDestroy(naviState);
 CleanupStack::PopAndDestroy(navigationalState);
 }
 TGlxMedia item = iMediaList->Item(focusIndex);
 TInt error = GlxErrorManager::HasAttributeErrorL(item.Properties(),
 KGlxMediaIdThumbnail);
+GLX_LOG_INFO1("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - error=%d", error);
 // Item will be supported by HDMI ONLY if
 // it is not a video
 // and it has valid DRM Viewing rights
 // and it has no attribute error
 if ( (item.Category() != EMPXVideo)
 && iDrmUtility->ItemRightsValidityCheckL(item.Uri(), ETrue)
 && (error == KErrNone) )
 {
-GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - Setting the Image");
+GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - Fetch FS thumbnail");
-iHdmiController->SetImageL(item.Uri());
+TMPXAttribute fsTnAttrib = TMPXAttribute(KGlxMediaIdThumbnail,
+GlxFullThumbnailAttributeId(ETrue, iScrnSize.iWidth,
+iScrnSize.iHeight));
+const CGlxThumbnailAttribute* fsValue = item.ThumbnailAttribute(
+fsTnAttrib);
+if (fsValue)
+{
+GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - Setting FS Bitmap");
+CFbsBitmap* fsBitmap = new (ELeave) CFbsBitmap;
+CleanupStack::PushL(fsBitmap);
+fsBitmap->Duplicate( fsValue->iBitmap->Handle());
+GLX_LOG_INFO2("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - FS Bitmap Size width=%d, height=%d",
+fsBitmap->SizeInPixels().iWidth, fsBitmap->SizeInPixels().iHeight);
+iHdmiController->SetImageL(item.Uri(),fsBitmap);
+CleanupStack::PopAndDestroy(fsBitmap);
+}
+else
+{
+GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - Fetch Grid thumbnail");
+TMPXAttribute gridTnAttrib = TMPXAttribute(KGlxMediaIdThumbnail,
+GlxFullThumbnailAttributeId(ETrue, iGridIconSize.iWidth,
+iGridIconSize.iHeight));
+const CGlxThumbnailAttribute* gridvalue = item.ThumbnailAttribute(
+gridTnAttrib);
+if (gridvalue)
+{
+GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - Setting Grid Bitmap");
+CFbsBitmap* gridBitmap = new (ELeave) CFbsBitmap;
+CleanupStack::PushL(gridBitmap);
+gridBitmap->Duplicate( gridvalue->iBitmap->Handle());
+GLX_LOG_INFO2("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - gridBitmap Size width=%d, height=%d",
+gridBitmap->SizeInPixels().iWidth, gridBitmap->SizeInPixels().iHeight);
+iHdmiController->SetImageL(item.Uri(),gridBitmap);
+CleanupStack::PopAndDestroy(gridBitmap);
+}
+else
+{
+GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - Setting Default Bitmap");
+TFileName resFile(KDC_APP_BITMAP_DIR);
+resFile.Append(KGlxIconsFilename);
+CFbsBitmap* defaultBitmap = new (ELeave) CFbsBitmap;
+CleanupStack::PushL(defaultBitmap);
+defaultBitmap = AknIconUtils::CreateIconL(resFile,
+EMbmGlxiconsQgn_prop_image_notcreated);
+GLX_LOG_INFO2("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - Default Size width=%d, height=%d",
+defaultBitmap->SizeInPixels().iWidth, defaultBitmap->SizeInPixels().iHeight);
+iHdmiController->SetImageL(item.Uri(),defaultBitmap);
+CleanupStack::PopAndDestroy(defaultBitmap);
+}
+}
 }
 else
 {
 GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - Unsupported Item");
 //Set the external display to cloning mode if
 //
 // ---------------------------------------------------------------------------
 void CGlxFullScreenViewImp::HandleMMCRemovalL()
 {
 TRACER("CGlxFullScreenViewImp::HandleMMCRemovalL()");
-if(iZoomControl && iZoomControl->Activated())
+iIsMMCRemoved = ETrue;
-{
+if(!iIsDialogLaunched)
-SetSliderLevel();
+{
-DeactivateZoomControlL();
+if(iZoomControl && iZoomControl->Activated())
-}
+{
-ProcessCommandL(EAknSoftkeyExit);
+SetSliderLevel();
+DeactivateZoomControlL();
+}
+ProcessCommandL(EAknSoftkeyExit);
+}
 }
 // ---------------------------------------------------------------------------
 // EnableFSToolbarL
 //

branch	RCL_3
changeset 25	191387a8b767
parent 22	2dac0fdba72b
child 30	a60acebbbd9d