--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/photosgallery/viewframework/texturemanager/src/glxtexturemanagerimpl.cpp Wed Sep 01 12:33:26 2010 +0100
@@ -0,0 +1,1536 @@
+/*
+* Copyright (c) 2008-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: Texture Manager
+*
+*/
+
+
+
+
+// INCLUDE FILES
+
+#include "glxtexturemanagerimpl.h"
+
+#include <AknIconUtils.h>
+#include <AknsUtils.h>
+#include <aknconsts.h>
+#include <alf/alftexturemanager.h>
+#include <alf/alfutil.h>
+#include <mpxmediadrmdefs.h>
+#include <mpxmediageneraldefs.h>
+
+#include <glxdrmutility.h>
+#include <glxmedia.h>
+#include <glxmediageneraldefs.h>
+#include <glxthumbnailattributeinfo.h>
+#include <glxthumbnailutility.h>
+#include <mglxcache.h>
+#include <glxresolutionutility.h>
+#include <glxlog.h>
+#include <glxtracer.h>
+#include <glxuiutility.h>
+#include "mglxtextureobserver.h"
+
+namespace
+ {
+ const TInt KGlxFirstAlfThumbnailTextureId = 0x10000001;
+ const TInt KGlxLastAlfThumbnailTextureId = 0x20000000;
+ const TInt KGlxFirstThumbnailTextureId = 0x20000001;
+ /** Bitmap size for flat (solid colour) textures */
+ const TInt KGlxFlatTextureSize = 64;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Constructor
+// -----------------------------------------------------------------------------
+//
+CGlxTextureManagerImpl::CGlxTextureManagerImpl
+ (CAlfTextureManager& aAlfTextureManager) :
+ iAlfTextureManager(aAlfTextureManager),
+ iNextTextureId( KGlxFirstThumbnailTextureId )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CGlxTextureManagerImpl::~CGlxTextureManagerImpl()
+ {
+ TRACER("CGlxTextureManagerImpl::~CGlxTextureManagerImpl");
+
+ // delete other icon textures
+ // iIconLIst should deleted only once in destructor as
+ // they are using in full applicaiton
+ TInt count = iIconList.Count();
+ for(TInt i = count - 1; i >= 0; i--)
+ {
+ delete iIconList[i].iTexture;
+ }
+ iIconList.Close();
+
+ iThumbnailList.Close();
+
+ iAnimatedTnmList.Close();
+
+ // delete DRM GIF textures
+ count = iDRMGifAnimatedTnmList.Count();
+ GLX_LOG_INFO1("CGlxTextureManagerImpl iDRMGifAnimatedTnmList.Count=%d",count);
+ for(TInt i = count - 1; i >= 0; i--)
+ {
+ GLX_LOG_INFO1("CGlxTextureManagerImpl DRM Gif Texture deleted i=%d",i);
+ for(TInt texCnt = KGlxMaxFrameCount - 1; texCnt >= 0; texCnt--)
+ {
+ delete iDRMGifAnimatedTnmList[i].iTexture[texCnt];
+ }
+ }
+ iDRMGifAnimatedTnmList.Close();
+
+ // delete zoom textures
+ count = iZoomedList.Count();
+ GLX_LOG_INFO1("CGlxTextureManagerImpl iZoomedList.Count=%d",count);
+ for(TInt i = count - 1; i >= 0; i--)
+ {
+ GLX_LOG_INFO1("CGlxTextureManagerImpldeleted i=%d",i);
+ delete iZoomedList[i].iTexture;
+ }
+ iZoomedList.Close();
+
+ delete iMifFilenames;
+
+ if ( iDrmUtility )
+ {
+ iDrmUtility->Close();
+ }
+
+ if ( iCache )
+ {
+ iCache->RemoveObserver(this);
+ iCache->Close();
+ }
+
+ if ( iResUtil )
+ {
+ iResUtil->RemoveObserver(*this);
+ iResUtil->Close();
+ }
+ if(iZoomDecoder)
+ {
+ delete iZoomDecoder;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// NewL
+// -----------------------------------------------------------------------------
+//
+CGlxTextureManagerImpl* CGlxTextureManagerImpl::NewL(
+ CAlfTextureManager& aAlfTextureManager)
+ {
+ TRACER("CGlxTextureManagerImpl::NewL");
+ CGlxTextureManagerImpl* self = CGlxTextureManagerImpl::NewLC(aAlfTextureManager);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// NewLC
+// -----------------------------------------------------------------------------
+//
+CGlxTextureManagerImpl* CGlxTextureManagerImpl::NewLC(
+ CAlfTextureManager& aAlfTextureManager)
+ {
+ TRACER("CGlxTextureManagerImpl::NewLC");
+ CGlxTextureManagerImpl* self =
+ new (ELeave) CGlxTextureManagerImpl(aAlfTextureManager);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// ConstructL
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::ConstructL()
+ {
+ TRACER("CGlxTextureManagerImpl::ConstructL");
+ iMifFilenames = new (ELeave) CDesCArrayFlat(2);
+
+ // get handle to DRM utility
+ iDrmUtility = CGlxDRMUtility::InstanceL();
+ // get handle to the media cache
+ iCache = MGlxCache::InstanceL();
+ iCache->AddObserverL(this);
+
+ // Get instance of Resolution utility and register for notification of
+ // resolution changes
+ /// @todo implement CGlxResolutionUtility this later
+ iResUtil = CGlxResolutionUtility::InstanceL();
+ iResUtil->AddObserverL(*this);
+ // Set the TextureId range. Now we can set our own ID outside this Range
+ iAlfTextureManager.SetAutomaticTextureIdRange(
+ KGlxFirstAlfThumbnailTextureId,
+ KGlxLastAlfThumbnailTextureId);
+ }
+
+
+// -----------------------------------------------------------------------------
+// TextureNeedsUpdating
+// -----------------------------------------------------------------------------
+//
+TBool CGlxTextureManagerImpl::TextureNeedsUpdating( TGlxMedia aMedia,
+ TGlxIdSpaceId aIdSpaceId, const TSize& aRequiredSize )
+ {
+ TRACER("CGlxTextureManagerImpl::TextureNeedsUpdating");
+ TInt thumbnailIndex = KErrNotFound;
+ TMPXAttribute thumbNailAttribute( 0, 0 );
+ TBool updateTexture = ETrue;
+ TRAPD( err, updateTexture = GetThumbnailAttributeAndIndexL( aRequiredSize,
+ aMedia, aIdSpaceId, thumbnailIndex, thumbNailAttribute ) );
+ // don't update the texture if there's an error
+ return ( err == KErrNone ? updateTexture : EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CreateIconTextureL
+// -----------------------------------------------------------------------------
+//
+CAlfTexture& CGlxTextureManagerImpl::CreateIconTextureL(
+ const TAknsItemID& aSkinID,
+ TInt aIconResourceId,
+ const TDesC& aFilename,
+ TBool aSetColor,
+ TRgb aDefaultColor,
+ const TAknsItemID& aSkinColorId,
+ TInt aSkinColorIndex,
+ TSize aRequestedSize)
+ {
+ TRACER("CGlxTextureManagerImpl::CreateIconTextureL");
+ // Convert size to POSS
+ TReal32 heightInPoss =
+ iResUtil->PixelsToPoss(TReal32(aRequestedSize.iHeight));
+
+ TReal32 widthInPoss =
+ iResUtil->PixelsToPoss(TReal32(aRequestedSize.iWidth));
+
+
+ CAlfTexture* texture = NULL;
+ //search array for existing item
+ TInt i = iIconList.Count();
+ while(i > 0 && !texture)
+ {
+ i--;
+ TGlxIcon icon = iIconList[i];
+ if( icon.iAvkonSkinId == aSkinID &&
+ icon.iBitmapId == aIconResourceId &&
+ icon.iSetColor == aSetColor &&
+ icon.iDefaultColor == aDefaultColor &&
+ icon.iSkinColorId == aSkinColorId &&
+ icon.iSkinColorIndex == aSkinColorIndex &&
+ icon.iHeightInPoss == heightInPoss &&
+ icon.iWidthInPoss == widthInPoss )
+ {
+ // also compare file names
+ TFileName filename(KNullDesC);
+ if(icon.iFilenameIndex >= 0)
+ {
+ filename = iMifFilenames->MdcaPoint(icon.iFilenameIndex);
+ }
+ if(0 == filename.CompareF(aFilename) )
+ {
+ // match found - use existing texture
+ texture = icon.iTexture;
+ }
+ }
+ }
+
+ if(!texture)
+ {
+ // existing texture not found - prepare to create new one
+ TInt filenameIndex = -1;
+ if(aFilename.Length() > 0)
+ {
+ // is filename already in filename list
+ if(iMifFilenames->MdcaCount())
+ {
+ iMifFilenames->Find(aFilename, filenameIndex);
+ if(filenameIndex == iMifFilenames->MdcaCount())
+ {
+ filenameIndex = -1;
+ }
+ }
+ if(filenameIndex < 0)
+ {
+ // name not in list. Add it
+ iMifFilenames->AppendL(aFilename);
+ filenameIndex = iMifFilenames->MdcaCount() - 1;
+ }
+ }
+ // Create new icon entry
+ TGlxIcon icon;
+ icon.iTextureId = NextTextureId();
+ icon.iTexture = NULL;
+ icon.iAvkonSkinId = aSkinID;
+ icon.iBitmapId = aIconResourceId;
+ icon.iFilenameIndex = filenameIndex;
+ icon.iSetColor = aSetColor;
+ icon.iDefaultColor = aDefaultColor;
+ icon.iSkinColorId = aSkinColorId;
+ icon.iSkinColorIndex = aSkinColorIndex;
+ icon.iHeightInPoss = heightInPoss;
+ icon.iWidthInPoss = widthInPoss;
+
+ // add to list so ProvideBitmapL can use it
+ iIconList.AppendL(icon);
+
+ // trap create texture
+ TRAPD(err, texture = &iAlfTextureManager.CreateTextureL(
+ icon.iTextureId,
+ this,
+ EAlfTextureFlagDefault));
+ if(err)
+ {
+ // if error delete entry and leave
+ iIconList.Remove(iIconList.Count() - 1);
+ User::Leave(err);
+ }
+ else
+ {
+ // if no error add texture to entry
+ iIconList[iIconList.Count() - 1].iTexture = texture;
+ }
+ }
+
+ if (NULL == texture)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ return *texture;
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CreateNewTextureForMediaL
+// -----------------------------------------------------------------------------
+//
+CAlfTexture& CGlxTextureManagerImpl::CreateNewTextureForMediaL(
+ TSize aSize,
+ const TGlxMedia& aMedia,
+ const TGlxIdSpaceId& aIdSpaceId,
+ MGlxTextureObserver* aObserver,
+ TBool aScaleGridTnm)
+ {
+ TRACER("CGlxTextureManagerImpl::CreateNewTextureForMediaL");
+ TInt thumbnailIndex = KErrNotFound;
+ TMPXAttribute thumbNailAttribute(0,0);
+ TGlxThumbnailIcon thumbData;
+
+ // If the current thumbnail matches what is required then return the current texture otherwise
+ // create a new one.
+ if (!GetThumbnailAttributeAndIndexL(aSize, aMedia, aIdSpaceId, thumbnailIndex, thumbNailAttribute))
+ {
+ // only texture is missing.
+ if ( (NULL != iThumbnailList[thumbnailIndex].iBitmap) && (NULL == iThumbnailList[thumbnailIndex].iTexture))
+ {
+ CAlfTexture* newTexture = &iAlfTextureManager.CreateTextureL(
+ iThumbnailList[thumbnailIndex].iTextureId,
+ this,
+ EAlfTextureFlagDefault);
+ iThumbnailList[thumbnailIndex].iTexture = newTexture ;
+ }
+ return *iThumbnailList[thumbnailIndex].iTexture;
+ }
+
+ // We have 2 scenarios here.
+ // 1) We do not have a thumbnail
+ // 2) The thumbnail we have is not good enough
+ iThumbnailList.ReserveL( iThumbnailList.Count() + 1 );
+
+ CAlfTexture& texture = CreateNewTextureL(aSize, aMedia, aIdSpaceId,
+ aObserver, thumbNailAttribute, thumbData,ETrue,aScaleGridTnm);
+
+
+ if ( thumbnailIndex != KErrNotFound )
+ {
+ // A new texture was created so remove the old one and
+ // update the thumbnail list.
+ iAlfTextureManager.UnloadTexture(iThumbnailList[thumbnailIndex].iTextureId);
+ iThumbnailList.Remove(thumbnailIndex);
+ GLX_LOG_INFO("CGlxTextureManagerImpl CreateNewTextureForMediaL UnloadTexture ");
+ }
+
+ return texture;
+ }
+
+// -----------------------------------------------------------------------------
+// CreateFlatColourTextureL
+// -----------------------------------------------------------------------------
+//
+CAlfTexture& CGlxTextureManagerImpl::CreateFlatColourTextureL( TRgb aColour )
+ {
+ TRACER("CGlxTextureManagerImpl::CreateFlatColourTextureL");
+ // Create a picture with the colour
+ CFbsBitmap* picture = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(picture);
+ User::LeaveIfError(picture->Create(TSize(KGlxFlatTextureSize,
+ KGlxFlatTextureSize), EColor16M ) );
+
+ CFbsBitmapDevice* drawBufDevice = CFbsBitmapDevice::NewL(picture);
+ CleanupStack::PushL(drawBufDevice);
+
+ CFbsBitGc* drawBufContext;
+ User::LeaveIfError(drawBufDevice->CreateContext(drawBufContext));
+ CleanupStack::PushL(drawBufContext);
+
+ // draw the color
+ drawBufContext->Activate(drawBufDevice);
+ drawBufContext->SetBrushColor(aColour);
+ drawBufContext->Clear();
+
+ TInt alpha = aColour.Alpha();
+
+ CleanupStack::PopAndDestroy(drawBufContext);
+ CleanupStack::PopAndDestroy(drawBufDevice);
+
+ CFbsBitmap* mask = NULL;
+ if( alpha != 0 )
+ {
+ mask = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL( mask );
+ User::LeaveIfError( mask->Create(TSize( KGlxFlatTextureSize,
+ KGlxFlatTextureSize ), EGray256 ));
+
+ CFbsBitmapDevice* maskBufDevice = CFbsBitmapDevice::NewL( mask );
+ CleanupStack::PushL( maskBufDevice );
+
+ CFbsBitGc* maskBufContext = NULL;
+ User::LeaveIfError( maskBufDevice->CreateContext( maskBufContext ) );
+ CleanupStack::PushL( maskBufContext );
+
+ // draw the mask
+ maskBufContext->Activate(maskBufDevice);
+ maskBufContext->SetBrushColor( TRgb::Color256( alpha ) );
+ maskBufContext->Clear();
+
+ CleanupStack::PopAndDestroy( maskBufContext );
+ CleanupStack::PopAndDestroy( maskBufDevice );
+ }
+
+ // Manage the texture ids ourself. Get the next id and store the
+ // associated bitmap and mask to ensure that we supply the correct bitmaps
+ // when alf calls back to ProvideBitmap
+ TInt nextTextureId = NextTextureId();
+ iProvideBitmapHolder.iTextureId = nextTextureId;
+ iProvideBitmapHolder.iBitmap = picture;
+ iProvideBitmapHolder.iMaskBitmap = mask;
+
+ CAlfTexture& newTexture = iAlfTextureManager.CreateTextureL(
+ nextTextureId,
+ this,
+ EAlfTextureFlagDefault );
+ // don't want alf to delete this texture
+ newTexture.SetPriority( EAlfTexturePriorityHighest );
+
+ // if we had alpha, release the mask
+ if( alpha != 0 )
+ {
+ CleanupStack::Pop( mask );
+ }
+
+ CleanupStack::Pop( picture );
+
+ return newTexture;
+ }
+
+
+// -----------------------------------------------------------------------------
+// RemoveTexture
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::RemoveTexture( const CAlfTexture& aTexture )
+ {
+ TRACER("CGlxTextureManagerImpl::RemoveTexture");
+ // Find the texture in the iThumbnailList
+ TInt index = iThumbnailList.Find( aTexture, &TGlxThumbnailIcon::MatchTexture );
+ if ( index != KErrNotFound )
+ {
+ iThumbnailList.Remove( index );
+ iAlfTextureManager.UnloadTexture( aTexture.Id() );
+ }
+ else
+ {
+ // Find the texture in the zoomed list
+ index = iZoomedList.Find( aTexture, &TGlxThumbnailIcon::MatchTexture );
+ GLX_LOG_INFO1("CGlxTextureManagerImpl RemoveTexture index=%d",index);
+ if ( index != KErrNotFound )
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl RemoveTexture index != KErrNotFound");
+ iAlfTextureManager.UnloadTexture( aTexture.Id() );
+ if(iZoomedList[index].iBitmap)
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl RemoveTexture iZoomedList[index].iBitmap delete");
+ delete iZoomedList[index].iBitmap;
+ iZoomedList[index].iBitmap=NULL;
+ iZoomedList.Remove( index );
+ }
+ }
+ // iIconLIst should deleted only once in destructor as
+ // they are using in full applicaiton
+ }
+
+ index = iAnimatedTnmList.Find( aTexture, &TGlxThumbnailIcon::MatchTexture );
+ GLX_LOG_INFO1("CGlxTextureManagerImpl RemoveTexture iAnimatedTnmList index=%d",index);
+ if ( index != KErrNotFound )
+ {
+ if(iAnimatedTnmList[index].iTexture)
+ {
+ GLX_LOG_INFO("RemoveTexture iAnimatedTnmList Stop animation");
+ (iAnimatedTnmList[index].iTexture)->StopAnimation();
+ }
+ iAnimatedTnmList.Remove( index );
+ iAlfTextureManager.UnloadTexture( aTexture.Id() );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// RemoveZoomList
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::RemoveZoomList()
+ {
+ TRACER("CGlxTextureManagerImpl::RemoveZoomList");
+ TInt count = iZoomedList.Count();
+ GLX_LOG_INFO1("CGlxTextureManagerImpl RemoveZoomList Count()=%d",count);
+ if(iZoomDecoder)
+ {
+ iZoomDecoder->Cancel();
+ }
+ for(TInt i = count - 1; i >= 0; i--)
+ {
+ iAlfTextureManager.UnloadTexture( iZoomedList[i].iTextureId );
+ if( iZoomedList[i].iBitmap)
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl RemoveZoomList delete iZoomedList[i]");
+ delete iZoomedList[i].iBitmap;
+ iZoomedList[i].iBitmap=NULL;
+ }
+ iZoomedList.Remove( i );
+ }
+ iZoomedList.Reset();
+
+ }
+
+// -----------------------------------------------------------------------------
+// RemoveTexture Using TGlxMediaId&
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::RemoveTexture(const TGlxMediaId& aMediaId,TBool aAllTexture )
+ {
+ TRACER("CGlxTextureManagerImpl::RemoveTexture 2");
+ //Bug fix for PKAA-7NRBYZ - added aAllTexture param
+ // Find the texture in the iThumbnailList
+ TInt i = iThumbnailList.Count();
+ while(i > 0)
+ {
+ --i;
+ if (iThumbnailList[i].iMediaId == aMediaId)
+ {
+ TInt aTexture = iThumbnailList[i].iTextureId;
+ iThumbnailList.Remove(i);
+ iAlfTextureManager.UnloadTexture(aTexture );
+ //Bug fix for PKAA-7NRBYZ - Delete all the texture only if it is asked.
+ if(!aAllTexture)
+ break;
+ }
+ }
+
+ i = iAnimatedTnmList.Count();
+
+ while(i > 0)
+ {
+ --i;
+ if (iAnimatedTnmList[i].iMediaId == aMediaId)
+ {
+ GLX_LOG_INFO("RemoveTexture 2 iAnimatedTnmList MediaID found");
+ TInt aTexture = iAnimatedTnmList[i].iTextureId;
+ if(iAnimatedTnmList[i].iTexture)
+ {
+ GLX_LOG_INFO("RemoveTexture2 iAnimatedTnmList Stop animation");
+ (iAnimatedTnmList[i].iTexture)->StopAnimation();
+ }
+ iAnimatedTnmList.Remove(i);
+ iAlfTextureManager.UnloadTexture(aTexture );
+ }
+ }
+
+ i = iDRMGifAnimatedTnmList.Count();
+
+ while(i > 0)
+ {
+ --i;
+ if (iDRMGifAnimatedTnmList[i].iMediaId == aMediaId)
+ {
+ GLX_LOG_INFO("RemoveTexture 2 iDRMGifAnimatedTnmList MediaId found");
+ for(TInt textureCnt=0;textureCnt<KGlxMaxFrameCount;textureCnt++)
+ {
+ TInt textureId = iDRMGifAnimatedTnmList[i].iTextureId[textureCnt];
+ iAlfTextureManager.UnloadTexture(textureId);
+ }
+ iDRMGifAnimatedTnmList.Remove(i);
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// FlushTextures Removes All Textures
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::FlushTextures()
+ {
+ TRACER("CGlxTextureManagerImpl::FlushTextures");
+
+ TInt textureID ;
+
+ TInt i = iThumbnailList.Count();
+ while(i > 0)
+ {
+ --i;
+ textureID = iThumbnailList[i].iTextureId;
+ iAlfTextureManager.UnloadTexture(textureID );
+ iThumbnailList[i].iTexture = NULL;
+ }
+
+ i = iIconList.Count();
+ while(i > 0)
+ {
+ --i;
+ textureID = iIconList[i].iTextureId;
+ iAlfTextureManager.UnloadTexture(textureID );
+ iIconList[i].iTexture = NULL;
+ }
+
+ i = iZoomedList.Count();
+ while(i > 0)
+ {
+ --i;
+ textureID = iZoomedList[i].iTextureId;
+ iAlfTextureManager.UnloadTexture(textureID );
+ iZoomedList[i].iTexture = NULL;
+ }
+
+ i = iAnimatedTnmList.Count();
+ while(i > 0)
+ {
+ --i;
+ textureID = iAnimatedTnmList[i].iTextureId;
+ if(iAnimatedTnmList[i].iTexture)
+ {
+ GLX_LOG_INFO("FlushTextures iAnimatedTnmList Stop animation");
+ (iAnimatedTnmList[i].iTexture)->StopAnimation();
+ }
+ iAlfTextureManager.UnloadTexture(textureID);
+ iAnimatedTnmList[i].iTexture = NULL;
+ }
+
+ i = iDRMGifAnimatedTnmList.Count();
+ while(i > 0)
+ {
+ --i;
+ GLX_LOG_INFO("RemoveTexture 2 iDRMGifAnimatedTnmList MediaId found");
+ for (TInt textureCnt = 0; textureCnt < KGlxMaxFrameCount; textureCnt++)
+ {
+ TInt aTexture = iDRMGifAnimatedTnmList[i].iTextureId[textureCnt];
+ iAlfTextureManager.UnloadTexture(aTexture);
+ iDRMGifAnimatedTnmList[i].iTexture[textureCnt] = NULL;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// GetThumbnailAttributeAndIndexL
+// -----------------------------------------------------------------------------
+//
+TBool CGlxTextureManagerImpl::GetThumbnailAttributeAndIndexL( TSize aSize,
+ const TGlxMedia& aMedia, const TGlxIdSpaceId& aIdSpaceId,
+ TInt& aThumbnailIndex, TMPXAttribute& aThumbnailAttribute )
+ {
+ TRACER("CGlxTextureManagerImpl::GetThumbnailAttributeAndIndexL");
+ GLX_LOG_INFO( "CGlxTextureManagerImpl::GetThumbnailAttributeAndIndexL" );
+ aThumbnailIndex = KErrNotFound;
+
+ aThumbnailAttribute = SelectAttributeL(aSize, aMedia); // Find Thumbnail attributes
+
+ TInt i = iThumbnailList.Count();
+ TTime reqTime;
+ aMedia.GetLastModifiedDate(reqTime);
+ while(i > 0 && aThumbnailIndex == KErrNotFound)
+ {
+ --i;
+ if ((iThumbnailList[i].iMediaId == aMedia.Id()) &&
+ (iThumbnailList[i].iIdSpaceId == aIdSpaceId) &&
+ (iThumbnailList[i].iImageDate == reqTime) &&
+ (iThumbnailList[i].iRequiredSize == aSize))
+ {
+ aThumbnailIndex = i;
+ if ( iThumbnailList[aThumbnailIndex].iAttribId == aThumbnailAttribute)
+ {
+ // We have found that the best match already exists
+ // No need to do anything
+ return EFalse;
+ }
+ }
+ }
+ return ETrue;
+ }
+// -----------------------------------------------------------------------------
+// CreateNewTextureL
+// -----------------------------------------------------------------------------
+CAlfTexture* CGlxTextureManagerImpl::CreateZoomedTextureL()
+ {
+ TRACER("CGlxTextureManagerImpl::CreateZoomedTextureL");
+ TInt count = iZoomedList.Count();
+ TInt index = 0 ;
+
+ for (index = count-1; index >=0 ; index--)
+ {
+ if (NULL == iZoomedList[index].iTexture)
+ {
+ if (NULL != iZoomedList[index].iBitmap)
+ {
+ // If we got this far we need to create a new texture
+ iZoomedList[index].iTextureId = NextTextureId();
+ iZoomedList[index].iTexture = &iAlfTextureManager.CreateTextureL(
+ iZoomedList[index].iTextureId,
+ this,
+ EAlfTextureFlagDefault);
+ return iZoomedList[index].iTexture ;
+ }
+ }
+ }
+ return NULL;
+ }
+// -----------------------------------------------------------------------------
+// CreateNewTextureL
+// -----------------------------------------------------------------------------
+CAlfTexture& CGlxTextureManagerImpl::CreateNewTextureL( TSize aSize,
+ const TGlxMedia& aMedia, const TGlxIdSpaceId& aIdSpaceId,
+ MGlxTextureObserver* aObserver, TMPXAttribute& aAttribute,
+ TGlxThumbnailIcon& aThumbData,TBool aIsThumbnailTexture, TBool aScaleGridTnm )
+ {
+ TRACER("CGlxTextureManagerImpl::CreateNewTextureL");
+ // This method only works if the call to CreateTextureL which in turn calls ProvideBitmapL behaves ina synchronous manor
+
+ // First find if there is an existing texture
+ // Find the texture in the iThumbnailList
+
+ // We have 2 scenarios here.
+ // 1) We do not have a thumbnail
+ // 2) The thumbnail we have is not good enough
+
+ aThumbData.iTextureId = NextTextureId();
+ aThumbData.iTexture = NULL;
+ aThumbData.iAttribId = aAttribute;
+ aThumbData.iMediaId = aMedia.Id();
+ aThumbData.iIdSpaceId = aIdSpaceId;
+ //Get the ThumbData creation date
+ aMedia.GetLastModifiedDate(aThumbData.iImageDate);
+ const CGlxThumbnailAttribute* thumb = aMedia.ThumbnailAttribute(aAttribute);
+ __ASSERT_DEBUG(thumb, Panic(EGlxPanicLogicError)); // thumb should not be NULL
+ aThumbData.iBitmap = thumb->iBitmap;
+ CFbsBitmap *scaledBitmap = NULL;
+
+ if(aScaleGridTnm)
+ {
+#ifdef _DEBUG
+ TTime startTime, stopTime;
+ startTime.HomeTime();
+#endif
+ TSize origSize;
+ aMedia.GetDimensions(origSize);
+ scaledBitmap = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL(scaledBitmap);
+ ScaleGridTnmToFsL(origSize,aSize,scaledBitmap,thumb);
+ aThumbData.iBitmap = scaledBitmap;
+
+#ifdef _DEBUG
+ stopTime.HomeTime();
+ GLX_LOG_INFO1("=>GRID TNM SCALE TO FS took <%d> us",
+ (TInt)stopTime.MicroSecondsFrom(startTime).Int64());
+#endif
+ }
+
+ if( aIsThumbnailTexture )
+ {
+ //Add to the thumbnail list
+ GLX_LOG_INFO("CGlxTextureManagerImpl::CreateNewTextureL iThumbnailList.AppendL");
+ iThumbnailList.AppendL(aThumbData);
+ }
+ else
+ {
+ GLX_LOG_INFO1("CGlxTextureManagerImpl::CreateNewTextureL,count=%d",iZoomedList.Count());
+ iZoomedList.AppendL(aThumbData);
+ }
+
+ // If we got this far we need to create a new texture
+ CAlfTexture* newTexture = &iAlfTextureManager.CreateTextureL(
+ aThumbData.iTextureId,
+ this,
+ EAlfTextureFlagDefault);
+
+
+ if( aIsThumbnailTexture )
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl::CreateNewTextureL aIsThumbnailTexture ");
+ TInt index = iThumbnailList.Count()-1;
+ iThumbnailList[index].iTexture = newTexture;
+ iThumbnailList[index].iRequiredSize = aSize;
+ }
+ else
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl::CreateNewTextureL else aIsThumbnailTexture ");
+ TInt index = iZoomedList.Count()-1;
+ iZoomedList[index].iTexture = newTexture;
+ iZoomedList[index].iRequiredSize = aSize;
+ iZoomedList[index].iBitmap=NULL;
+ }
+
+ if (aObserver)
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl::CreateNewTextureL aObserver ");
+ aThumbData.iObserver = aObserver;
+ aThumbData.iObserver->TextureContentChangedL( ETrue , newTexture);
+ }
+
+ if(scaledBitmap)
+ {
+ CleanupStack::PopAndDestroy(scaledBitmap);
+ }
+
+ return *newTexture;
+ }
+
+// -----------------------------------------------------------------------------
+// CreateZoomedTextureL
+// -----------------------------------------------------------------------------
+//
+CAlfTexture& CGlxTextureManagerImpl::CreateZoomedTextureL(
+ const TGlxMedia& aMedia, const TMPXAttribute& aAttribute,
+ TGlxIdSpaceId aIdSpaceId, MGlxTextureObserver* aObserver)
+ {
+ TRACER("CGlxTextureManagerImpl::CreateZoomedTextureL");
+ if(!iZoomDecoder)
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl:: CreateZoomedTextureL,iZoomDecoder == NULL");
+ iZoomDecoder = CGlxBitmapDecoderWrapper::NewL(this);
+ }
+
+ TGlxThumbnailIcon aThumbData;
+
+ aThumbData.iTextureId = NextTextureId();
+ aThumbData.iTexture = NULL;
+ aThumbData.iAttribId = aAttribute;
+ aThumbData.iMediaId = aMedia.Id();
+ aThumbData.iIdSpaceId = aIdSpaceId;
+
+ //Add to the thumbnail list
+ iZoomedList.AppendL(aThumbData);
+
+ TInt index = iZoomedList.Count()-1;
+ GLX_LOG_INFO1("CGlxTextureManagerImpl:: CreateZoomedTextureL,index=%d",index);
+
+ iZoomedList[index].iTexture = NULL;
+ aMedia.GetDimensions( iZoomedList[index].iRequiredSize );
+
+ iZoomedList[index].iBitmap=NULL;
+ iZoomedList[index].iObserver = aObserver ;
+
+ iZoomDecoder->DoDecodeImageL(aMedia.Uri(), iZoomedList.Count()-1);
+ return *(iZoomedList[index].iTexture);
+ }
+
+// -----------------------------------------------------------------------------
+// CreateAnimatedGifTextureL
+// -----------------------------------------------------------------------------
+//
+CAlfTexture& CGlxTextureManagerImpl::CreateAnimatedGifTextureL(
+ const TDesC& aFilename, const TSize& aSize,const TGlxMedia& aMedia,
+ TGlxIdSpaceId aIdSpaceId)
+ {
+ TRACER("CGlxTextureManagerImpl::CreateAnimatedGifTextureL");
+ TInt thumbnailIndex = KErrNotFound;
+
+ // If the current thumbnail matches what is required then return the current texture otherwise
+ // create a new one.
+ if (!GetAnimatedGifThumbnailIndex( aSize, aMedia, aIdSpaceId,thumbnailIndex))
+ {
+ GLX_LOG_INFO("CreateAnimatedGifTextureL Texture already present");
+ // only texture is missing.
+ if ((NULL == iAnimatedTnmList[thumbnailIndex].iTexture))
+ {
+ CAlfTexture& newTexture = iAlfTextureManager.LoadTextureL(aFilename,aSize,
+ EAlfTextureFlagDefault,iAnimatedTnmList[thumbnailIndex].iTextureId );
+ iAnimatedTnmList[thumbnailIndex].iTexture = &newTexture ;
+ }
+ // While reloading texture, Need to start animaiton with
+ // explicit call as we stopped animation while unloading texture
+ // This is not required when creating a new texture as Alf
+ // starts animation by default on those textures.
+ (iAnimatedTnmList[thumbnailIndex].iTexture)->StartAnimation();
+ return *iAnimatedTnmList[thumbnailIndex].iTexture;
+ }
+
+ TGlxThumbnailIcon thumbData;
+ thumbData.iTextureId = NextTextureId();
+ thumbData.iTexture = NULL;
+ thumbData.iMediaId = aMedia.Id();
+ thumbData.iIdSpaceId = aIdSpaceId;
+
+ iAnimatedTnmList.ReserveL( iAnimatedTnmList.Count() + 1 );
+
+ iAnimatedTnmList.AppendL(thumbData);
+
+ CAlfTexture& newTexture = iAlfTextureManager.LoadTextureL(aFilename,aSize,
+ EAlfTextureFlagDefault,thumbData.iTextureId );
+
+ TInt index = iAnimatedTnmList.Count()-1;
+ iAnimatedTnmList[index].iTexture = &newTexture;
+ iAnimatedTnmList[index].iRequiredSize = aSize;
+
+ return newTexture;
+ }
+
+
+// -----------------------------------------------------------------------------
+// UpdateTexture
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::UpdateTexture()
+ {
+ TRACER("CGlxTextureManagerImpl::UpdateTexture");
+ TInt count = iIconList.Count();
+ for(TInt i = count - 1; i >= 0; i--)
+ {
+ //to-check
+ // TRAP_IGNORE(DoHandleResolutionChangedL(i);)
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// HandleResolutionChanged
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::HandleResolutionChangedL()
+ {
+ TRACER("CGlxTextureManagerImpl::HandleResolutionChangedL");
+ UpdateTexture();
+ }
+
+// -----------------------------------------------------------------------------
+// ProvideBitmapL
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::ProvideBitmapL(TInt aTextureId,
+ CFbsBitmap*& aBitmap,
+ CFbsBitmap*& aMaskBitmap)
+ {
+ TRACER("CGlxTextureManagerImpl::ProvideBitmapL");
+ // Test whether we've already created bitmaps for the given texture id
+ if ( aTextureId == iProvideBitmapHolder.iTextureId )
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl::ProvideBitmapL aTextureId");
+ aBitmap = iProvideBitmapHolder.iBitmap;
+ aMaskBitmap = iProvideBitmapHolder.iMaskBitmap;
+ // reset the flags to prevent multiple calls into here
+ iProvideBitmapHolder.iTextureId = KErrNotFound;
+ iProvideBitmapHolder.iBitmap = NULL;
+ iProvideBitmapHolder.iMaskBitmap = NULL;
+ return;
+ }
+
+ // loop to search the zoomed thumbnail list
+ TInt i = iZoomedList.Count();
+ GLX_LOG_INFO1("CGlxTextureManagerImpl::ProvideBitmapL iZoomedList.Count=%d",i);
+ while(i > 0)
+ {
+ --i;
+ if (iZoomedList[i].iTextureId == aTextureId)
+ {
+ // We have found the texture, create a duplicate as alf destroys
+ // the bitmap once the texture's been created.
+ GLX_LOG_INFO1("CGlxTextureManagerImpl::ProvideBitmapL i=%d",i);
+ aBitmap = CreateDuplicateBitmapL( *iZoomedList[i].iBitmap );
+ return;
+ }
+ }
+ // add loop to search the iThumbnailList for the aTextureId
+ i = iThumbnailList.Count();
+ while(i > 0)
+ {
+ --i;
+ if ((iThumbnailList[i].iTextureId == aTextureId))
+ {
+ // We have found the texture, create a duplicate as alf destroys
+ // the bitmap once the texture's been created.
+ aBitmap = CreateDuplicateBitmapL( *iThumbnailList[i].iBitmap );
+ return;
+ }
+ }
+
+ // add loop to search the iDRMGifAnimatedTnmList for the aTextureId
+ i = iDRMGifAnimatedTnmList.Count();
+ while (i > 0)
+ {
+ --i;
+ for(TInt textureCnt=0;textureCnt<KGlxMaxFrameCount;textureCnt++)
+ {
+ if (iDRMGifAnimatedTnmList[i].iBitmap[textureCnt] &&
+ (iDRMGifAnimatedTnmList[i].iTextureId[textureCnt] == aTextureId))
+ {
+ // We have found the texture, create a duplicate as alf destroys
+ // the bitmap once the texture's been created.
+ aBitmap = CreateDuplicateBitmapL(*iDRMGifAnimatedTnmList[i].iBitmap[textureCnt]);
+ if(iDRMGifAnimatedTnmList[i].iBitmapMask[textureCnt])
+ {
+ aMaskBitmap = CreateDuplicateBitmapL(*iDRMGifAnimatedTnmList[i].iBitmapMask[textureCnt]);
+ }
+ return;
+ }
+ }
+ }
+
+ // find in iIconList
+ i = iIconList.Count();
+ TBool found = EFalse;
+ TGlxIcon icon;
+ while(i > 0 && !found)
+ {
+ i--;
+ if(iIconList[i].iTextureId == aTextureId)
+ {
+ icon = iIconList[i];
+ found = ETrue;
+ }
+ }
+
+ if(!found)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ TInt bitmapId = icon.iBitmapId;
+ TInt maskId = bitmapId;
+ if(bitmapId)
+ {
+ maskId++;
+ }
+
+ TFileName filename(KNullDesC);
+ if(icon.iFilenameIndex >= 0)
+ {
+ filename = iMifFilenames->MdcaPoint(icon.iFilenameIndex);
+ }
+
+ if(icon.iSetColor)
+ {
+ AknsUtils::CreateColorIconL( AknsUtils::SkinInstance(),
+ icon.iAvkonSkinId,
+ icon.iSkinColorId,
+ icon.iSkinColorIndex,
+ aBitmap,
+ aMaskBitmap,
+ filename,
+ bitmapId,
+ maskId,
+ icon.iDefaultColor );
+ }
+ else
+ {
+ AknsUtils::CreateIconL( AknsUtils::SkinInstance(),
+ icon.iAvkonSkinId,
+ aBitmap,
+ aMaskBitmap,
+ filename,
+ bitmapId,
+ maskId );
+ }
+
+ // Leave if bitmap or mask is NULL.
+
+ if (NULL == aBitmap)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ // set size
+ // In preference use requested size if there is one
+ TInt height =TInt(iResUtil->PossToPixels(icon.iHeightInPoss));
+ TInt width =TInt(iResUtil->PossToPixels(icon.iWidthInPoss));
+
+ TSize size(width, height);
+
+ // Disable compression so that the bitmap may be able to be
+ // duplicated inside HUITK when BITGDI renderer is in use.
+ AknIconUtils::DisableCompression( aBitmap );
+
+ if ( size == TSize(0, 0) )
+ {
+ // If no requested size use original size of the graphic
+ TAknContentDimensions origDim;
+ AknIconUtils::GetContentDimensions(aBitmap, origDim);
+ size = TSize(origDim.iWidth, origDim.iHeight);
+
+ // But if the original size is small make smallest dimension 64
+ // and keep aspect ratio
+ if ( size.iHeight < 64 && size.iWidth < 64 )
+ {
+ if(origDim.iWidth < origDim.iHeight)
+ {
+ size = TSize(64, 64.0F * origDim.iHeight / origDim.iWidth);
+ }
+ else
+ {
+ size = TSize(64.0F * origDim.iWidth / origDim.iHeight, 64);
+ }
+ }
+ }
+ AknIconUtils::SetSize(aBitmap, size, EAspectRatioNotPreserved);
+ }
+
+// -----------------------------------------------------------------------------
+// SelectAttributeL
+// -----------------------------------------------------------------------------
+//
+TMPXAttribute CGlxTextureManagerImpl::SelectAttributeL( TSize& aSize,
+ const TGlxMedia& aMedia )
+ {
+ TRACER("CGlxTextureManagerImpl::SelectAttributeL");
+ const CGlxMedia& media = *aMedia.Properties();
+ if ( !aMedia.Properties() || media.Count() == 0 )
+ {
+ GLX_LOG_INFO("SelectAttributeL - NULL CGlxMedia / No Attribs");
+ User::Leave( KErrArgument );
+ }
+ // first check if DRM protected
+ TBool drmInvalid = EFalse;
+ if ( aMedia.GetDrmProtected(drmInvalid) && drmInvalid )
+ {
+ // require URI attribute
+ TMPXGeneralCategory cat = aMedia.Category();
+ // get URI
+ const TDesC& uri = aMedia.Uri();
+ if( (uri.Length() == 0) || (EMPXNoCategory == cat) )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ // check if rights have expired
+ TBool checkViewRights = (cat==EMPXImage);
+
+ //Since uri can be either focused or unfocused item
+ //better call ItemRightsValidityCheckL which doesn't modify lastconsumedUri.
+ CreateImageViewerInstanceL();
+ if(iImageViewerInstance->IsPrivate())
+ {
+ drmInvalid = !iDrmUtility->ItemRightsValidityCheckL(iImageViewerInstance->ImageFileHandle(), checkViewRights);
+ }
+ else
+ {
+ drmInvalid = !iDrmUtility->ItemRightsValidityCheckL(uri, checkViewRights);
+ }
+ DeleteImageViewerInstance();
+ CGlxMedia* properties = const_cast<CGlxMedia*>(aMedia.Properties());
+ if( !drmInvalid )
+ {
+ properties->SetTObjectValueL(KGlxMediaGeneralDRMRightsValid, EGlxDrmRightsValid);
+ }
+ else
+ {
+ properties->SetTObjectValueL(KGlxMediaGeneralDRMRightsValid, EGlxDrmRightsInvalid);
+ }
+ }
+
+ // if invalid need dimensions
+ if ( drmInvalid )
+ {
+ TSize dimensions(0,0);
+ if(!aMedia.GetDimensions(dimensions))
+ {
+ User::Leave( KErrArgument );
+ }
+
+ aSize = iDrmUtility->DRMThumbnailSize(dimensions);
+ }
+
+ // Get the index for the attribute
+ TInt index = GlxThumbnailUtility::ClosestThumbnail( aSize,
+ media, !drmInvalid );
+ // check it's valid
+ if (KErrNotFound == index)
+ {
+ GLX_LOG_INFO("GlxThumbnailUtility::ClosestThumbnail fail ");
+ User::Leave( KErrArgument );
+ }
+
+ return media.Attribute(index);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CreateDuplicateBitmapL
+// -----------------------------------------------------------------------------
+//
+CFbsBitmap* CGlxTextureManagerImpl::CreateDuplicateBitmapL(CFbsBitmap& aOriginalBitmap )
+ {
+ TRACER("CGlxTextureManagerImpl::CreateDuplicateBitmapL");
+ CFbsBitmap* duplicateBitmap = new( ELeave) CFbsBitmap();
+ TInt err=duplicateBitmap->Duplicate( aOriginalBitmap.Handle());
+ if ( err != KErrNone )
+ {
+ delete duplicateBitmap;
+ duplicateBitmap = NULL;
+ GLX_LOG_INFO1("CGlxTextureManagerImpl::CreateDuplicateBitmapL fail =%d",err);
+ }
+
+ return duplicateBitmap;
+ }
+
+// -----------------------------------------------------------------------------
+// NextTextureId
+// -----------------------------------------------------------------------------
+//
+TInt CGlxTextureManagerImpl::NextTextureId()
+ {
+ TRACER("CGlxTextureManagerImpl::NextTextureId");
+ return ++iNextTextureId;
+ }
+
+
+// -----------------------------------------------------------------------------
+// HandleBitmapDecodedL
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::HandleBitmapDecodedL(TInt aThumbnailIndex,CFbsBitmap* aBitmap)
+ {
+ TRACER("CGlxTextureManagerImpl::HandleBitmapDecodedL");
+ CAlfTexture* newTexture = NULL;
+ TBool textureCreated = ETrue;
+ TInt textureID = -1;
+ TInt textureToBeUnloaded = -1;
+
+ //check if the image is decoded
+ if ( aBitmap )
+ {
+ iZoomedList[aThumbnailIndex].iBitmap = aBitmap;
+
+ CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();
+ CleanupClosePushL(*uiUtility);
+ TBool foregroundStatus = uiUtility->GetForegroundStatus();
+ CleanupStack::PopAndDestroy(uiUtility);
+
+ // Photos not in foreground; do not create zoom texture
+ if (!foregroundStatus)
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl HandleBitmapDecodedL - Not in foreground; do not create zoom texture");
+ return;
+ }
+
+ //if we already have a texture then dont unload the texture before creating
+ //the next one. It might happen that because of low memory we might not be able
+ //to create a new texture.
+ if(iZoomedList[aThumbnailIndex].iTexture)
+ {
+ textureID = NextTextureId();
+ textureToBeUnloaded = iZoomedList[aThumbnailIndex].iTextureId ;
+ iZoomedList[aThumbnailIndex].iTextureId = textureID ;
+ }
+ else
+ {
+ textureID = iZoomedList[aThumbnailIndex].iTextureId;
+ }
+
+ TRAPD(err, newTexture = &iAlfTextureManager.CreateTextureL(
+ textureID, this, EAlfTextureFlagDefault));
+ if ( KErrNone != err && KErrNoMemory == err )
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded ReleaseRam : START RAM RELEASE");
+ iCache->ReleaseRAML(ETrue);
+ TRAPD(err, newTexture = &iAlfTextureManager.CreateTextureL(textureID, this, EAlfTextureFlagDefault));
+ if ( KErrNone != err && KErrNoMemory == err )
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded CreateTextureL : LOW MEMORY CONDITION");
+ textureCreated = EFalse;
+ }
+ }
+ }
+ else
+ {
+ textureCreated = EFalse;
+ }
+
+
+
+ if (textureCreated && (NULL != newTexture))
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded textureCreated && newTexture");
+ //If the new texture is created then unload the old texture and store the new texture and textureID.
+ if(iZoomedList[aThumbnailIndex].iTexture)
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded Unloading Old Texture");
+ iAlfTextureManager.UnloadTexture(textureToBeUnloaded );
+ }
+ iZoomedList[aThumbnailIndex].iTextureId = textureID;
+ iZoomedList[aThumbnailIndex].iTexture = newTexture;
+ }
+
+ if (iZoomedList[aThumbnailIndex].iObserver)
+ {
+ GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecoded TextureContentChangedL");
+ iZoomedList[aThumbnailIndex].iObserver->TextureContentChangedL( textureCreated ,iZoomedList[aThumbnailIndex].iTexture);
+ }
+ GLX_LOG_INFO("CGlxTextureManagerImpl::HandleBitmapDecodedL Exit ");
+ }
+
+// -----------------------------------------------------------------------------
+// HandleAttributesAvailableL
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::HandleAttributesAvailableL(
+ const TGlxIdSpaceId& /*aIdSpaceId*/, const TGlxMediaId& /*aMediaId*/,
+ const RArray<TMPXAttribute>& /*aAttributes*/,
+ const CGlxMedia* /*aMedia*/)
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CleanupTextureCacheL
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::CleanupMedia(const TGlxMediaId& aMediaId)
+ {
+ TRACER("CGlxTextureManagerImpl::CleanupMedia");
+ RemoveTexture(aMediaId, EFalse);
+ }
+
+// -----------------------------------------------------------------------------
+// ScaleGridTnmToFsL
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::ScaleGridTnmToFsL(TSize aSrcSize, TSize aDestSize,
+ CFbsBitmap *aScaledBitmap, const CGlxThumbnailAttribute* thumb)
+ {
+ TRACER("CGlxTextureManagerImpl::ScaleGridTnmToFsL");
+ // Scale the Image to required size if the thumbnail is smaller.Instead of Displaying Small thumbnail
+ // Calculate destination rect to maintain aspect ratio
+ TReal aspectRatio = (TReal)aDestSize.iWidth/(TReal)aDestSize.iHeight ;
+ TReal thumbAspectRatio = (TReal)aSrcSize.iWidth/(TReal)aSrcSize.iHeight ;
+ TSize destinationSize ;
+ if(thumbAspectRatio >= aspectRatio)
+ {
+ destinationSize.iWidth = aDestSize.iWidth ;
+ destinationSize.iHeight = aDestSize.iWidth*aSrcSize.iHeight/aSrcSize.iWidth ;
+ }
+ else
+ {
+ destinationSize.iHeight = aDestSize.iHeight ;
+ destinationSize.iWidth = aDestSize.iHeight*aSrcSize.iWidth/aSrcSize.iHeight ;
+ }
+ aScaledBitmap->Create(destinationSize,thumb->iBitmap->DisplayMode());
+ CFbsBitmapDevice *bitmapDevice = CFbsBitmapDevice::NewL(aScaledBitmap);
+ CleanupStack::PushL(bitmapDevice);
+ CFbsBitGc * bitmapGc = CFbsBitGc::NewL();
+ CleanupStack::PushL(bitmapGc);
+ bitmapGc->Activate(bitmapDevice);
+ bitmapGc->DrawBitmap(TRect(destinationSize),thumb->iBitmap);
+ CleanupStack::PopAndDestroy(bitmapGc);
+ CleanupStack::PopAndDestroy(bitmapDevice);
+ GLX_LOG_INFO2("===== Actual Image Size %d x %d",aSrcSize.iWidth,aSrcSize.iHeight);
+ GLX_LOG_INFO2("===== Scaled Image Size %d x %d",destinationSize.iWidth,destinationSize.iHeight);
+ }
+
+
+// -----------------------------------------------------------------------------
+// GetAnimatedGifThumbnailIndex
+// -----------------------------------------------------------------------------
+//
+TBool CGlxTextureManagerImpl::GetAnimatedGifThumbnailIndex( TSize aSize,
+ const TGlxMedia& aMedia, const TGlxIdSpaceId& aIdSpaceId,
+ TInt& aThumbnailIndex)
+ {
+ TRACER("CGlxTextureManagerImpl::GetAnimatedGifThumbnailIndex");
+ aThumbnailIndex = KErrNotFound;
+
+ TInt i = iAnimatedTnmList.Count();
+
+ while(i > 0 && aThumbnailIndex == KErrNotFound)
+ {
+ --i;
+ if ((iAnimatedTnmList[i].iMediaId == aMedia.Id()) &&
+ (iAnimatedTnmList[i].iIdSpaceId == aIdSpaceId) &&
+ (iAnimatedTnmList[i].iRequiredSize == aSize))
+ {
+ aThumbnailIndex = i;
+ GLX_LOG_INFO( "GetAnimatedGifThumbnailIndex textureid present" );
+ // We have found that the best match already exists
+ // No need to do anything
+ return EFalse;
+ }
+ }
+ return ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// CreateImageViewerInstanceL
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::CreateImageViewerInstanceL()
+ {
+ TRACER("CGlxTextureManagerImpl::CreateImageViewerInstanceL");
+ iImageViewerInstance = CGlxImageViewerManager::InstanceL();
+ __ASSERT_ALWAYS(iImageViewerInstance, Panic(EGlxPanicNullPointer));
+ }
+
+// -----------------------------------------------------------------------------
+// DeleteImageViewerInstance
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::DeleteImageViewerInstance()
+ {
+ TRACER("CGlxTextureManagerImpl::DeleteImageViewerInstance");
+ if ( iImageViewerInstance )
+ {
+ iImageViewerInstance->DeleteInstance();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// AnimateMediaItem
+// -----------------------------------------------------------------------------
+//
+void CGlxTextureManagerImpl::AnimateMediaItem(const TGlxMediaId& aMediaId,
+ TBool aState)
+ {
+ TRACER("CGlxTextureManagerImpl::AnimateMediaItem");
+ TInt index = iAnimatedTnmList.Find(aMediaId,
+ &TGlxThumbnailIcon::MatchMediaId);
+ if (index != KErrNotFound)
+ {
+ if (iAnimatedTnmList[index].iTexture)
+ {
+ if (aState)
+ {
+ GLX_LOG_INFO("AnimateMediaItem - Start animation");
+ (iAnimatedTnmList[index].iTexture)->StartAnimation();
+ }
+ else
+ {
+ GLX_LOG_INFO("AnimateMediaItem - Stop animation");
+ (iAnimatedTnmList[index].iTexture)->StopAnimation();
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CreateDRMAnimatedGifTextureL
+// -----------------------------------------------------------------------------
+//
+CAlfTexture& CGlxTextureManagerImpl::CreateDRMAnimatedGifTextureL(const TGlxMedia& aMedia,
+ TGlxIdSpaceId aIdSpaceId,TInt aFrameNumber, CFbsBitmap* aBitmap, CFbsBitmap* aBitmapMask)
+ {
+ TRACER("CGlxTextureManagerImpl::CreateDRMAnimatedGifTextureL");
+ TInt thumbnailIndex = KErrNotFound;
+
+ // If the current thumbnail matches what is required then return the current texture otherwise
+ // create a new one.
+ if (!GetDRMAnimatedGifThumbnailIndex( aMedia, aIdSpaceId,thumbnailIndex))
+ {
+ GLX_LOG_INFO("CreateDRMAnimatedGifTextureL Texture already present");
+ // only texture is missing.
+ if ((NULL == iDRMGifAnimatedTnmList[thumbnailIndex].iTexture[aFrameNumber]))
+ {
+ if(NULL == iDRMGifAnimatedTnmList[thumbnailIndex].iBitmap[aFrameNumber])
+ {
+ iDRMGifAnimatedTnmList[thumbnailIndex].iTextureId[aFrameNumber] = NextTextureId();
+ iDRMGifAnimatedTnmList[thumbnailIndex].iBitmap[aFrameNumber] = aBitmap;
+ iDRMGifAnimatedTnmList[thumbnailIndex].iBitmapMask[aFrameNumber] = aBitmapMask;
+ }
+ CAlfTexture* newTexture = &iAlfTextureManager.CreateTextureL(
+ iDRMGifAnimatedTnmList[thumbnailIndex].iTextureId[aFrameNumber],
+ this,
+ EAlfTextureFlagDefault);
+ iDRMGifAnimatedTnmList[thumbnailIndex].iTexture[aFrameNumber] = newTexture;
+ }
+ return *iDRMGifAnimatedTnmList[thumbnailIndex].iTexture[aFrameNumber];
+ }
+
+ TGlxDRMGifThumbnailIcon thumbData;
+ thumbData.iTextureId[aFrameNumber] = NextTextureId();
+ thumbData.iMediaId = aMedia.Id();
+ thumbData.iIdSpaceId = aIdSpaceId;
+ for(TInt i=0;i<KGlxMaxFrameCount;i++)
+ {
+ thumbData.iTexture[i] = NULL;
+ thumbData.iBitmap[i] = NULL;
+ thumbData.iBitmapMask[i] = NULL;
+ }
+ thumbData.iBitmap[aFrameNumber] = aBitmap;
+ thumbData.iBitmapMask[aFrameNumber] = aBitmapMask;
+
+ iDRMGifAnimatedTnmList.ReserveL( iDRMGifAnimatedTnmList.Count() + 1 );
+
+ iDRMGifAnimatedTnmList.AppendL(thumbData);
+
+ CAlfTexture* newTexture = &iAlfTextureManager.CreateTextureL(
+ thumbData.iTextureId[aFrameNumber],
+ this,
+ EAlfTextureFlagDefault);
+
+ TInt index = iDRMGifAnimatedTnmList.Count()-1;
+ iDRMGifAnimatedTnmList[index].iTexture[aFrameNumber] = newTexture;
+
+ return *newTexture;
+ }
+
+
+// -----------------------------------------------------------------------------
+// GetAnimatedGifThumbnailIndex
+// -----------------------------------------------------------------------------
+//
+TBool CGlxTextureManagerImpl::GetDRMAnimatedGifThumbnailIndex(const TGlxMedia& aMedia, const TGlxIdSpaceId& aIdSpaceId,
+ TInt& aThumbnailIndex)
+ {
+ TRACER("CGlxTextureManagerImpl::GetDRMAnimatedGifThumbnailIndex");
+ aThumbnailIndex = KErrNotFound;
+
+ TInt i = iDRMGifAnimatedTnmList.Count();
+
+ while (i > 0 && aThumbnailIndex == KErrNotFound)
+ {
+ --i;
+ if ((iDRMGifAnimatedTnmList[i].iMediaId == aMedia.Id())
+ && (iDRMGifAnimatedTnmList[i].iIdSpaceId == aIdSpaceId))
+ {
+ aThumbnailIndex = i;
+ GLX_LOG_INFO( "GetDRMAnimatedGifThumbnailIndex textureid present" );
+ // We have found that the best match already exists
+ // No need to do anything
+ return EFalse;
+ }
+ }
+ return ETrue;
+ }