--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/Client/src/alfimageloaderutil.cpp Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,1071 @@
+/*
+* Copyright (c) 2006 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: Utility for loading skin graphics.
+*
+*/
+
+
+
+
+#include "alf/alfimageloaderutil.h"
+#include "alf/alfbitmapprovider.h"
+#include "alf/alfstatic.h"
+#include "alf/alfenv.h"
+#include <SVGEngineInterfaceImpl.h>
+#include <SVGRequestObserver.h>
+#include <AknsItemData.h>
+#include <AknsUtils.h>
+
+#include <uiacceltk/HuiUtil.h>
+
+// Set this flag to ETrue if autosize textures need to be exluded from Avkon
+// icon cache, e.g. because it get filled with different size variants of same icon.
+// Excluding is likely to decrease texture upload performance.
+const TBool KExcludeAutosizeTextureIconsFromAvkonIconCache = EFalse;
+
+const TInt KSkinFrameBorderWidthDefaultValue = 8;
+const TInt KSkinFrameBorderWidthSmallValue = 4;
+const TInt KSkinFrameBorderWidthSmallestValue = 1;
+const TInt KSkinFrameWidthMinValue = 1;
+
+const TInt KAlfImageLoaderDefaultWidth = 4;
+const TInt KAlfImageLoaderDefaultHeight = 4;
+const TScaleMode KAlfImageLoaderDefaultScaleMode = EAspectRatioPreserved;
+
+struct TAlfProvidedBitmap
+ {
+ TInt iId;
+ TSize iPreferredSize;
+ };
+
+/**
+ * Base class of the image loader classes
+ */
+class CAlfImageLoader: public CBase, public MAlfBitmapProvider, public MAlfTextureAutoSizeObserver
+ {
+public:
+ CAlfImageLoader();
+
+ ~CAlfImageLoader();
+
+ /**
+ * Set size of the icon. This must be called before creating texture.
+ * This call only sets information and dees *NOT* cause any scalable icon rasterization.
+ *
+ * @param aSize Size in pixel.
+ */
+ void SetSize(TSize aSize) {iSize = aSize;}
+
+ void SetScaleMode(TScaleMode aScaleMode) {iScaleMode = aScaleMode;}
+
+ /**
+ * Set skin instance, which is acquired from AknsUtils::SkinInstance().
+ *
+ * @param aSkinInstance An Avkon skin instamce.
+ */
+ void SetSkinInstance(MAknsSkinInstance *aSkinInstance) {iSkinInstance = aSkinInstance;}
+
+public:
+ // From MHuiBitmapProvider
+ virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;
+
+ // From MHuiTextureAutoSizeObserver
+ virtual TBool PreferredSizeChanged(const CAlfTexture& aChangedTexture, TSize aPreferredSize);
+
+protected:
+ MAknsSkinInstance* GetValidSkinInstance();
+ TSize PreferredSize(TInt aId) const;
+
+protected:
+ // common source info data
+ MAknsSkinInstance *iSkinInstance;
+ TSize iSize;
+ TScaleMode iScaleMode;
+ RArray<TAlfProvidedBitmap> iProvidedBitmaps;
+ TBool iExcludeFromAvkonIconCache;
+ };
+
+
+/**
+ * Image loader utility for skin item image loading.
+ *
+ */
+NONSHARABLE_CLASS(CAlfSkinItemImageLoader): public CAlfImageLoader
+{
+public:
+
+ /**
+ * Default constructor
+ */
+ CAlfSkinItemImageLoader();
+
+ /**
+ * Construct an icon source information with Avkon skin item ID. AknsUtils::CreateIconL()
+ * will be called in RAlfImageLoaderUtil::CreateIconL().
+ *
+ * @param aInstance Skin instance.
+ * @param aID An ID of the graphical item (e.g. an icon).
+ * @param aBitmapId ID of the bitmap when fallback is used.
+ * @param aMaskId ID of the mask bitmap when fallback is used.
+ */
+ CAlfSkinItemImageLoader( const TAknsItemID &aID, TInt aBitmapId, TInt aMaskId );
+
+ /**
+ * Construct an icon source information with Avkon skin item ID. AknsUtils::CreateIconL()
+ * will be called in RAlfImageLoaderUtil::CreateIconL().
+ *
+ * @param aFileName File name of graphics file e.g. mif file) when sepcified item is not found in the current skin.
+ */
+ void ConstructL( const TDesC &aFileName );
+
+ /**
+ * Destructor
+ */
+ ~CAlfSkinItemImageLoader();
+
+ /**
+ * Implementation of MAlfBitmapProvider interface.
+ *
+ * @param aId A unique ID of the texture needed to provide bitmaps.
+ * @param aBitmap A bitmap.
+ * @param aMaskBitmap A mask bitmap.
+ */
+ virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;
+
+protected:
+ TAknsItemID iId;
+ HBufC* iFileName;
+ TInt iBitmapId;
+ TInt iMaskId;
+};
+
+
+/**
+ * Image loader utility for skin frame item image loading.
+ *
+ */
+NONSHARABLE_CLASS(CAlfSkinFrameItemImageLoader): public CAlfSkinItemImageLoader
+{
+public:
+
+ enum TFrameParts
+ {
+ EFramePartCornerTl = 0,
+ EFramePartCornerTr,
+ EFramePartCornerBl,
+ EFramePartCornerBr,
+ EFramePartSideT,
+ EFramePartSideB,
+ EFramePartSideL,
+ EFramePartSideR,
+ EFramePartCenter
+ };
+
+ /**
+ * Create MAlfBitmapProvider instance to load frame image with Avkon skin item ID.
+ * @param aFrameID An Akvon skin item ID of the graphical frame item to load.
+ * @param aInnerRect Inner rect of the frame
+ * @param aOuterRect Outer rect of the frame
+ */
+ CAlfSkinFrameItemImageLoader( const TAknsItemID &aFrameID, const TRect& aInnerRect, const TRect& aOuterRect );
+
+ /**
+ * Construct an icon source information with Avkon skin item ID. AknsUtils::CreateIconL()
+ * will be called in RAlfImageLoaderUtil::CreateIconL().
+ *
+ * @param aFileName File name of graphics file e.g. mif file) when sepcified item is not found in the current skin.
+ * @param aBitmapId ID of the bitmap when fallback is used.
+ * @param aMaskId ID of the mask bitmap when fallback is used.
+ */
+ void ConstructL( const TDesC &aFileName, TInt aBitmapId, TInt aMaskId );
+
+ /**
+ * Destructor
+ */
+ ~CAlfSkinFrameItemImageLoader();
+
+ /**
+ * Implementation of MAlfBitmapProvider interface.
+ *
+ * @param aId A unique ID of the texture needed to provide bitmaps.
+ * @param aBitmap A bitmap.
+ * @param aMaskBitmap A mask bitmap.
+ */
+ virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;
+
+private:
+
+ TSize GetFramePartSize(const TFrameParts aFramePart, const TSize& aFullFrameSize) const;
+ TPoint GetFramePartPos(const TFrameParts aFramePart, const TSize& aFullFrameSize) const;
+ TRect AdjustedOuterRect(const TSize& aFullFrameSize) const;
+ TRect AdjustedInnerRect(const TSize& aFullFrameSize) const;
+ TInt FrameBorderWidth() const;
+
+private:
+
+ TRect iInnerRect;
+ TRect iOuterRect;
+};
+
+/**
+ * Image loader utility for loading Svg Images
+ *
+ */
+NONSHARABLE_CLASS(CAlfSvgImageLoader): public CAlfImageLoader, public MSvgRequestObserver
+{
+public:
+
+ /**
+ * Construct an SVG loader
+ *
+ * @param aSVGFile Svg File name.
+ */
+ static CAlfSvgImageLoader* NewLC(const TDesC& aSVGFile);
+
+ /**
+ * Destructor
+ */
+ ~CAlfSvgImageLoader();
+
+ /**
+ * Implementation of MAlfBitmapProvider interface.
+ *
+ * @param aId A unique ID of the texture needed to provide bitmaps.
+ * @param aBitmap A bitmap.
+ * @param aMaskBitmap A mask bitmap.
+ */
+ virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;
+
+ /**
+ * Implementation of MSvgRequestObserver interface. - UpdateScreen
+ */
+ void UpdateScreen();
+
+ /**
+ * Implementation of MSvgRequestObserver interface. - ScriptCall
+ */
+ TBool ScriptCall( const TDesC& aScript,CSvgElementImpl* aCallerElement );
+
+ /**
+ * Implementation of MSvgRequestObserver interface.- FetchImage
+ */
+ TInt FetchImage( const TDesC& aUri, RFs& aSession, RFile& aFileHandle );
+
+ /**
+ * Implementation of MSvgRequestObserver interface.-UpdatePresentation
+ */
+ void UpdatePresentation(const TInt32& aNoOfAnimation);
+
+ /**
+ * Implementation of MSvgRequestObserver interface.-FetchFont
+ */
+ TInt FetchFont( const TDesC& aUri, RFs& aSession, RFile& aFileHandle );
+
+private:
+ CAlfSvgImageLoader();
+ void ConstructL(const TDesC& aSVGFile);
+ void LoadSVGFileL(TInt aId);
+private:
+ CSvgEngineInterfaceImpl* iSvgEngine;//owned
+ CFbsBitmap* iBitmap;//not owned
+ CFbsBitmap* iMask; //not owned
+ CFbsBitmap* iDummyBitmap;//owned
+ HBufC* iFileName;
+};
+
+CAlfSvgImageLoader::~CAlfSvgImageLoader()
+{
+ delete iSvgEngine;
+ delete iDummyBitmap;
+ delete iBitmap;
+ delete iMask;
+ delete iFileName;
+}
+// -----------------------------------------------------------------------------
+// CSVGPerfTestAppView::UpdateScreen
+// -----------------------------------------------------------------------------
+//
+void CAlfSvgImageLoader::UpdateScreen()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CSVGPerfTestAppView::ScriptCall
+// -----------------------------------------------------------------------------
+//
+TBool CAlfSvgImageLoader::ScriptCall(
+ const TDesC& /*aScript*/,
+ CSvgElementImpl* /*aCallerElement*/ )
+ {
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CAlfSvgImageLoader::FetchImage
+// -----------------------------------------------------------------------------
+//
+TInt CAlfSvgImageLoader:: FetchImage(
+ const TDesC& /*aUri*/, RFs& /*aSession*/, RFile& /*aFileHandle*/ )
+ {
+ return KErrNotSupported;
+ }
+
+// -----------------------------------------------------------------------------
+// CSVGPerfTestAppView::UpdatePresentation
+// -----------------------------------------------------------------------------
+//
+void CAlfSvgImageLoader::UpdatePresentation(
+ const TInt32& /*aNoOfAnimation*/ )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CAlfSvgImageLoader::UpdatePresentation
+// -----------------------------------------------------------------------------
+//
+TInt CAlfSvgImageLoader::FetchFont( const TDesC& /*aUri*/, RFs& /*aSession*/, RFile& /*aFileHandle*/ )
+ {
+ return KErrNotSupported;
+ }
+
+
+void CAlfSvgImageLoader::LoadSVGFileL(TInt aId)
+{
+ // delete previous content
+
+ delete iBitmap;
+ iBitmap = NULL;
+ delete iMask;
+ iMask = NULL;
+
+ // create frame and frame mask buffers
+ iBitmap = new( ELeave ) CFbsBitmap;
+ User::LeaveIfError( iBitmap->Create( PreferredSize(aId), EColor64K ) );
+
+ iMask = new( ELeave ) CFbsBitmap;
+ User::LeaveIfError( iMask->Create( PreferredSize(aId), EGray256 ) );
+
+
+ // If filename does not contain full path, then prepend the path from
+ // primary envs default texture manager.
+ TFileName filename;
+ TParsePtrC parse(*iFileName);
+ if (!parse.DrivePresent())
+ {
+ filename.Append(CAlfStatic::Env().TextureManager().ImagePath());
+ }
+ filename.Append(*iFileName);
+
+ // Load and render SVG file
+ TInt handle = 0;
+ iSvgEngine->PrepareDom( filename, handle ) ;
+ iSvgEngine->UseDom( handle, iBitmap, iMask );
+
+ // check the aspect ratio (taken from AknSvgFormatHandler.cpp)
+ TSvgPreserveAspectAlignType alignTypeValue = ESvgPreserveAspectRatio_XmidYmid;
+ TSvgMeetOrSliceType meetOrSliceTypeValue = ESvgMeetOrSlice_Meet;
+ switch ( iScaleMode )
+ {
+ case EAspectRatioPreserved: // fall through
+ {
+ // use default
+ break;
+ }
+ // Ensures SVG content fully covers
+ // the area of the icon whilst preserving aspect ratio.
+ case EAspectRatioPreservedSlice:
+ {
+ // alignTypeValue use default
+ meetOrSliceTypeValue = ESvgMeetOrSlice_Slice;
+ break;
+ }
+ // EAspectRatioPreservedAndUnusedSpaceRemoved is mapped to
+ // the same values as EAspectRatioNotPreserved
+ // because we already have a frame buffer
+ // with the dimensions that preserves the aspect ratio.
+ // This mapping ensures that SVG engine does not calculate aspect
+ // ratio twice and potentially resulting in precision loss.
+ case EAspectRatioPreservedAndUnusedSpaceRemoved:
+ case EAspectRatioNotPreserved:
+ {
+ alignTypeValue = ESvgPreserveAspectRatio_None;
+ // meetOrSliceTypeValue use default
+ break;
+ }
+ default:
+ {
+ __ASSERT_DEBUG( 0, USER_INVARIANT() );
+ }
+ }
+
+ iSvgEngine->SetPreserveAspectRatio( NULL, alignTypeValue, meetOrSliceTypeValue, ETrue);
+
+
+ // render frame and frame mask
+ iSvgEngine->Start();
+ iSvgEngine->UseDom( handle, NULL, NULL );
+ iSvgEngine->DeleteDom( handle );
+
+}
+
+CAlfSvgImageLoader* CAlfSvgImageLoader::NewLC(const TDesC& aSVGFile)
+ {
+ CAlfSvgImageLoader* self = new ( ELeave ) CAlfSvgImageLoader();
+ CleanupStack::PushL( self );
+ self->ConstructL(aSVGFile);
+ return self;
+ }
+
+CAlfSvgImageLoader::CAlfSvgImageLoader()
+ {
+ }
+
+void CAlfSvgImageLoader::ConstructL(const TDesC& aSVGFile)
+ {
+ iFileName = aSVGFile.AllocL();
+ // Initialize SVG engine
+ TFontSpec spec;
+ if ( !iDummyBitmap )
+ {
+ // Have to give some bitmap to the engine in the constructor.
+ iDummyBitmap = new( ELeave ) CFbsBitmap;
+ TInt error = iDummyBitmap->Create( TSize( 0, 0 ), EGray2 );
+ if ( error != KErrNone )
+ {
+ delete iDummyBitmap;
+ iDummyBitmap = NULL;
+ User::Leave( error );
+ }
+ }
+
+ iSvgEngine = CSvgEngineInterfaceImpl::NewL( iDummyBitmap, this, spec );
+ iSvgEngine->SetBackgroundColor( 0 );
+ // No DRM check needed.
+ iSvgEngine->SetDRMMode( EFalse );
+ }
+
+void CAlfSvgImageLoader::ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap)
+{
+ CAlfImageLoader::ProvideBitmapL (aId, aBitmap, aMaskBitmap);
+
+ LoadSVGFileL(aId);
+ aBitmap = iBitmap; //ownership transfered
+ aMaskBitmap = iMask; // ownership transfered
+ iBitmap = NULL;
+ iMask = NULL;
+}
+
+
+/**
+ * Image loader utility for application icon loading.
+ *
+ */
+NONSHARABLE_CLASS(CAlfAppIconImageLoader): public CAlfImageLoader
+{
+public:
+ /**
+ * Construct an icon source information to create application icon. AknsUtils::CreateAppIconLC()
+ * will be called in RAlfImageLoaderUtil::CreateIconL().
+ *
+ * @param aInstance Skin instance.
+ * @param aAppUid Application UID of the icon to be created.
+ * @param aType Type of the application icon. Likely EAknsAppIconTypeContext is used...
+ */
+ CAlfAppIconImageLoader(TUid aAppUid, TAknsAppIconType aType);
+
+ /**
+ * Implementation of MAlfBitmapProvider interface.
+ *
+ * @param aId A unique ID of the texture needed to provide bitmaps.
+ * @param aBitmap A bitmap.
+ * @param aMaskBitmap A mask bitmap.
+ */
+ virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;
+private:
+ TUid iAppUid;
+ TAknsAppIconType iType;
+};
+
+// Image loader util
+EXPORT_C CAlfImageLoaderUtil::CAlfImageLoaderUtil()
+ :iSize(KAlfImageLoaderDefaultWidth,
+ KAlfImageLoaderDefaultHeight),
+ iScaleMode(KAlfImageLoaderDefaultScaleMode)
+ {
+ }
+
+
+EXPORT_C CAlfImageLoaderUtil::~CAlfImageLoaderUtil()
+ {
+ for (TInt i=0; i<iImageLoaderList.Count(); i++)
+ delete iImageLoaderList[i];
+ iImageLoaderList.Close();
+ }
+
+
+EXPORT_C MAlfBitmapProvider* CAlfImageLoaderUtil::CreateImageLoaderL(
+ const TAknsItemID &aID,
+ const TDesC &aFileName,
+ TInt aBitmapId,
+ TInt aMaskId)
+ {
+ // Create frame item loader, it can also handle normal items.
+ CAlfSkinFrameItemImageLoader* imgLoader = new (ELeave) CAlfSkinFrameItemImageLoader(
+ aID, TRect(0,0,0,0), TRect(0,0,0,0));
+
+ CleanupStack::PushL( imgLoader );
+ imgLoader->ConstructL( aFileName, aBitmapId, aMaskId );
+ imgLoader->SetSize(iSize);
+ imgLoader->SetScaleMode(iScaleMode);
+ imgLoader->SetSkinInstance(iSkinInstance);
+ iImageLoaderList.AppendL(imgLoader);
+ CleanupStack::Pop( imgLoader );
+ return imgLoader;
+ }
+
+EXPORT_C MAlfBitmapProvider* CAlfImageLoaderUtil::CreateImageLoaderL(
+ const TAknsItemID &aFrameID,
+ const TRect& aInnerRect,
+ const TRect& aOuterRect)
+ {
+ CAlfSkinItemImageLoader* imgLoader = new (ELeave) CAlfSkinFrameItemImageLoader(
+ aFrameID, aInnerRect, aOuterRect);
+ CleanupStack::PushL( imgLoader );
+ imgLoader->SetSize(aOuterRect.Size());
+ imgLoader->SetScaleMode(iScaleMode);
+ imgLoader->SetSkinInstance(iSkinInstance);
+ iImageLoaderList.AppendL(imgLoader);
+ CleanupStack::Pop( imgLoader );
+ return imgLoader;
+ }
+
+
+
+EXPORT_C MAlfBitmapProvider* CAlfImageLoaderUtil::CreateSVGImageLoaderL(
+ const TDesC &aFileName)
+ {
+ CAlfSvgImageLoader* imgLoader = CAlfSvgImageLoader::NewLC(aFileName);
+ imgLoader->SetSize(iSize);
+ imgLoader->SetScaleMode(iScaleMode);
+ iImageLoaderList.AppendL(imgLoader);
+ CleanupStack::Pop( imgLoader );
+ return imgLoader;
+ }
+
+
+EXPORT_C MAlfBitmapProvider* CAlfImageLoaderUtil::CreateImageLoaderL(
+ TUid aAppUid,
+ TAknsAppIconType aType)
+ {
+ CAlfAppIconImageLoader* imgLoader = new (ELeave) CAlfAppIconImageLoader(
+ aAppUid, aType);
+ CleanupStack::PushL( imgLoader );
+ imgLoader->SetSize(iSize);
+ imgLoader->SetScaleMode(iScaleMode);
+ imgLoader->SetSkinInstance(iSkinInstance);
+ iImageLoaderList.AppendL(imgLoader);
+ CleanupStack::Pop( imgLoader );
+ return imgLoader;
+ }
+
+
+EXPORT_C void CAlfImageLoaderUtil::SetSize(TSize aSize, TScaleMode aMode)
+ {
+ iSize = aSize;
+ iScaleMode = aMode;
+ }
+
+
+EXPORT_C void CAlfImageLoaderUtil::SetSkinInstance(MAknsSkinInstance *aSkinInstance)
+ {
+ iSkinInstance = aSkinInstance;
+ }
+
+
+// Image loaders
+CAlfImageLoader::CAlfImageLoader():
+ iSize(KAlfImageLoaderDefaultWidth,KAlfImageLoaderDefaultHeight),
+ iScaleMode(KAlfImageLoaderDefaultScaleMode)
+ {
+ }
+
+CAlfImageLoader::~CAlfImageLoader()
+ {
+ iProvidedBitmaps.Close();
+ };
+
+MAknsSkinInstance* CAlfImageLoader::GetValidSkinInstance()
+ {
+ if (iSkinInstance == NULL)
+ {
+ return AknsUtils::SkinInstance();
+ }
+ else
+ {
+ return iSkinInstance;
+ }
+ }
+
+TSize CAlfImageLoader::PreferredSize(TInt aId) const
+ {
+ for(TInt i = 0; i < iProvidedBitmaps.Count(); i++)
+ {
+ if (iProvidedBitmaps[i].iId == aId)
+ {
+ // Already in list
+ return iProvidedBitmaps[i].iPreferredSize;
+ }
+ }
+ return iSize;
+ }
+
+
+TBool CAlfImageLoader::PreferredSizeChanged(const CAlfTexture& aChangedTexture, TSize aPreferredSize)
+ {
+ // Check if any of my bitmaps preferred size has changed
+ for(TInt ii = 0; ii < iProvidedBitmaps.Count(); ii++)
+ {
+ if (iProvidedBitmaps[ii].iId == aChangedTexture.Id())
+ {
+ iProvidedBitmaps[ii].iPreferredSize = aPreferredSize;
+
+ TInt flags = aChangedTexture.Flags();
+
+ // Exclude autosized bitmaps from avkon icon cache
+ if (KExcludeAutosizeTextureIconsFromAvkonIconCache &&
+ (flags & EAlfTextureFlagAutoSize))
+ {
+ iExcludeFromAvkonIconCache = ETrue;
+ }
+
+ // If bitmap is excuded from avkon cache, we can use direct upload to gain slight
+ // performance improvement in bitgdi. No fear of anyone sharing the bitmap or compressing
+ // it etc.
+ if (iExcludeFromAvkonIconCache)
+ {
+ flags |= 0x20; // "Secret" flag, not in public API
+ CAlfTexture* changedTexture = const_cast<CAlfTexture*> (&aChangedTexture);
+ changedTexture->SetFlags(TAlfTextureFlags(flags));
+ }
+
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+void CAlfImageLoader::ProvideBitmapL (TInt aId, CFbsBitmap *& /*aBitmap*/, CFbsBitmap *& /*aMaskBitmap*/)
+ {
+ for(TInt i = 0; i < iProvidedBitmaps.Count(); i++)
+ {
+ if (iProvidedBitmaps[i].iId == aId)
+ {
+ // Already in list, do nothing
+ return;
+ }
+ }
+
+ // If provided bitmap is not yet in the list, add it.
+ TAlfProvidedBitmap providedBitmap;
+ providedBitmap.iId = aId;
+ providedBitmap.iPreferredSize = iSize;
+ iProvidedBitmaps.AppendL(providedBitmap);
+ }
+
+
+CAlfSkinItemImageLoader::CAlfSkinItemImageLoader():
+ iId(KAknsIIDNone),
+ iFileName(NULL),
+ iBitmapId(0),
+ iMaskId(0)
+ {
+ }
+
+CAlfSkinItemImageLoader::CAlfSkinItemImageLoader(
+ const TAknsItemID &aID,
+ TInt aBitmapId,
+ TInt aMaskId):
+ iId(aID),
+ iBitmapId(aBitmapId),
+ iMaskId(aMaskId)
+ {
+ }
+
+void CAlfSkinItemImageLoader::ConstructL( const TDesC &aFileName )
+ {
+ iFileName = aFileName.AllocL();
+ }
+
+CAlfSkinItemImageLoader::~CAlfSkinItemImageLoader()
+ {
+ delete iFileName;
+ }
+
+
+void CAlfSkinItemImageLoader::ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap)
+ {
+ CAlfImageLoader::ProvideBitmapL (aId, aBitmap, aMaskBitmap);
+
+ AknsUtils::CreateIconL(
+ GetValidSkinInstance(), iId,
+ aBitmap, aMaskBitmap,
+ *iFileName, iBitmapId, iMaskId);
+
+ // Leave if bitmap or mask is NULL.
+ User::LeaveIfNull( aBitmap );
+ //User::LeaveIfNull( aMaskBitmap );
+
+ // Disable compression so that the bitmap may be able to be duplicated inside
+ // AlfTK when BITGDI renderer is in use.
+ AknIconUtils::DisableCompression( aBitmap );
+
+ // Exclude from icon cache to avoid flooding it or to avoid bitmap sharing
+ if (iExcludeFromAvkonIconCache)
+ {
+ AknIconUtils::ExcludeFromCache( aBitmap );
+ }
+
+ // Set icon sizes and render them on the bitmaps.
+ // This does the actual rendering to specified size. (SVG -> bitmap)
+ AknIconUtils::SetSize( aBitmap, PreferredSize(aId), iScaleMode );
+ }
+
+
+
+CAlfSkinFrameItemImageLoader::CAlfSkinFrameItemImageLoader( const TAknsItemID &aFrameID,
+ const TRect& aInnerRect,
+ const TRect& aOuterRect ):
+ iInnerRect(aInnerRect),
+ iOuterRect(aOuterRect)
+ {
+ iId = aFrameID;
+
+ // Sanity check to avoid evil things happening later
+ if (aOuterRect.iTl.iX - aInnerRect.iTl.iX > KSkinFrameWidthMinValue ||
+ aOuterRect.iTl.iY - aInnerRect.iTl.iY > KSkinFrameWidthMinValue ||
+ aOuterRect.iBr.iX - aInnerRect.iBr.iX < KSkinFrameWidthMinValue ||
+ aOuterRect.iBr.iY - aInnerRect.iBr.iY < KSkinFrameWidthMinValue)
+ {
+ iInnerRect = TRect(0,0,0,0);
+ iOuterRect = TRect(0,0,0,0);
+ }
+ }
+
+void CAlfSkinFrameItemImageLoader::ConstructL( const TDesC &aFileName, TInt aBitmapId, TInt aMaskId )
+ {
+ iBitmapId = aBitmapId;
+ iMaskId = aMaskId;
+ iFileName = aFileName.AllocL();
+ }
+
+CAlfSkinFrameItemImageLoader::~CAlfSkinFrameItemImageLoader()
+ {
+ // base class deletes iFileName
+ }
+
+void CAlfSkinFrameItemImageLoader::ProvideBitmapL(TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap)
+ {
+ CAknsItemData* itemData = NULL;
+ itemData = AknsUtils::SkinInstance()->CreateUncachedItemDataL( iId, EAknsITImageTable );
+
+ if (itemData)
+ {
+ // Call grandparent class functionality instead of parent here.
+ CAlfImageLoader::ProvideBitmapL (aId, aBitmap, aMaskBitmap);
+
+ CAknsImageTableItemData* itemTableData = static_cast<CAknsImageTableItemData*>(itemData);
+ CleanupStack::PushL( itemTableData );
+
+ TSize frameSize = PreferredSize(aId);
+
+ // Create target bitmap
+ aBitmap = new CFbsBitmap();
+ aBitmap->Create( frameSize, EColor64K );
+
+ aMaskBitmap = new CFbsBitmap();
+ aMaskBitmap->Create( frameSize, EGray256 );
+
+ // Create bitmap device for target rendering
+ CFbsBitmapDevice* targetDevice = CFbsBitmapDevice::NewL( aBitmap );
+ CleanupStack::PushL( targetDevice );
+
+ CFbsBitmapDevice* targetMaskDevice = CFbsBitmapDevice::NewL( aMaskBitmap );
+ CleanupStack::PushL( targetMaskDevice );
+
+ // Create bitmap graphics context
+ CFbsBitGc* bitgc = CFbsBitGc::NewL();
+ CleanupStack::PushL( bitgc );
+ bitgc->Activate( targetDevice );
+
+ CFbsBitGc* maskbitgc = CFbsBitGc::NewL();
+ CleanupStack::PushL( maskbitgc );
+ maskbitgc->Activate( targetMaskDevice );
+
+ // Fill mask just in case there are unmasked elements in the frame
+ maskbitgc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ maskbitgc->SetBrushColor(KRgbWhite);
+ maskbitgc->SetPenColor(KRgbWhite);
+ maskbitgc->DrawRect(TRect(TPoint(0,0), frameSize));
+
+ // 9 part frame graphics
+ for (TInt count = 0; count < 9; count++)
+ {
+ TSize partsize = GetFramePartSize((TFrameParts)(count), frameSize);
+ TPoint partpos = GetFramePartPos((TFrameParts)(count), frameSize);
+
+ TAknsItemID partSkinId = itemTableData->ImageIID(count);
+
+ CFbsBitmap* partBitmap = NULL;
+ CFbsBitmap* partMaskBitmap = NULL;
+ AknsUtils::GetCachedMaskedBitmap(AknsUtils::SkinInstance(), itemTableData->ImageIID(count), partBitmap, partMaskBitmap );
+
+ TRect sourcerect = TRect(TPoint(0,0), partsize);
+
+ if (partBitmap)
+ {
+ AknIconUtils::SetSize( partBitmap, partsize, EAspectRatioNotPreserved );
+ bitgc->BitBlt(partpos, partBitmap,sourcerect);
+ }
+
+ if (partMaskBitmap)
+ {
+ AknIconUtils::SetSize( partMaskBitmap, partsize, EAspectRatioNotPreserved );
+ maskbitgc->BitBlt(partpos, partMaskBitmap,sourcerect);
+ }
+ }
+
+ CleanupStack::PopAndDestroy( maskbitgc );
+ CleanupStack::PopAndDestroy( bitgc );
+ CleanupStack::PopAndDestroy( targetMaskDevice );
+ CleanupStack::PopAndDestroy( targetDevice );
+ CleanupStack::PopAndDestroy( itemTableData );
+ }
+ else
+ {
+ // 1 part frame graphics comes from the base class
+ CAlfSkinItemImageLoader::ProvideBitmapL(aId, aBitmap, aMaskBitmap);
+ }
+
+ }
+
+TSize CAlfSkinFrameItemImageLoader::GetFramePartSize(const TFrameParts aFramePart, const TSize& aFullFrameSize) const
+ {
+ TRect innerRect = AdjustedInnerRect(aFullFrameSize);
+ TRect outerRect = AdjustedOuterRect(aFullFrameSize);
+
+ TSize size(0,0);
+
+ switch (aFramePart)
+ {
+ case EFramePartCornerTl:
+ size.iWidth = innerRect.iTl.iX - outerRect.iTl.iX;
+ size.iHeight = innerRect.iTl.iY - outerRect.iTl.iY;
+ break;
+ case EFramePartCornerTr:
+ size.iWidth = outerRect.iBr.iX - innerRect.iBr.iX;
+ size.iHeight = innerRect.iTl.iY - outerRect.iTl.iY;
+ break;
+ case EFramePartCornerBl:
+ size.iWidth = innerRect.iTl.iX - outerRect.iTl.iX;
+ size.iHeight = outerRect.iBr.iY - innerRect.iBr.iY;
+ break;
+ case EFramePartCornerBr:
+ size.iWidth = outerRect.iBr.iX - innerRect.iBr.iX;
+ size.iHeight = outerRect.iBr.iY - innerRect.iBr.iY;
+ break;
+ case EFramePartSideT:
+ size.iWidth = innerRect.iBr.iX - innerRect.iTl.iX;
+ size.iHeight = innerRect.iTl.iY - outerRect.iTl.iY;
+ break;
+ case EFramePartSideB:
+ size.iWidth = innerRect.iBr.iX - innerRect.iTl.iX;
+ size.iHeight = outerRect.iBr.iY - innerRect.iBr.iY;
+ break;
+ case EFramePartSideL:
+ size.iWidth = innerRect.iTl.iX - outerRect.iTl.iX;
+ size.iHeight = innerRect.iBr.iY - innerRect.iTl.iY;
+ break;
+ case EFramePartSideR:
+ size.iWidth = outerRect.iBr.iX - innerRect.iBr.iX;
+ size.iHeight = innerRect.iBr.iY - innerRect.iTl.iY;
+ break;
+ case EFramePartCenter:
+ size = innerRect.Size();
+ break;
+ default:
+ break;
+ }
+ return size;
+ }
+
+TPoint CAlfSkinFrameItemImageLoader::GetFramePartPos(const TFrameParts aFramePart, const TSize& aFullFrameSize) const
+ {
+ TRect innerRect = AdjustedInnerRect(aFullFrameSize);
+ TRect outerRect = AdjustedOuterRect(aFullFrameSize);
+
+ TPoint pos(0,0);
+
+ switch (aFramePart)
+ {
+ case EFramePartCornerTl:
+ pos.iX = outerRect.iTl.iX;
+ pos.iY = outerRect.iTl.iY;
+ break;
+ case EFramePartCornerTr:
+ pos.iX = innerRect.iBr.iX;
+ pos.iY = outerRect.iTl.iY;
+ break;
+ case EFramePartCornerBl:
+ pos.iX = outerRect.iTl.iX;
+ pos.iY = innerRect.iBr.iY;
+ break;
+ case EFramePartCornerBr:
+ pos.iX = innerRect.iBr.iX;
+ pos.iY = innerRect.iBr.iY;
+ break;
+ case EFramePartSideT:
+ pos.iX = innerRect.iTl.iX;
+ pos.iY = outerRect.iTl.iY;
+ break;
+ case EFramePartSideB:
+ pos.iX = innerRect.iTl.iX;
+ pos.iY = innerRect.iBr.iY;
+ break;
+ case EFramePartSideL:
+ pos.iX = outerRect.iTl.iX;
+ pos.iY = innerRect.iTl.iY;
+ break;
+ case EFramePartSideR:
+ pos.iX = innerRect.iBr.iX;
+ pos.iY = innerRect.iTl.iY;
+ break;
+ case EFramePartCenter:
+ pos.iX = innerRect.iTl.iX;
+ pos.iY = innerRect.iTl.iY;
+ break;
+ default:
+ break;
+ }
+ return pos;
+ }
+
+TRect CAlfSkinFrameItemImageLoader::AdjustedOuterRect(const TSize& aFullFrameSize) const
+ {
+ if (aFullFrameSize != iOuterRect.Size())
+ {
+ return TRect(TPoint(0,0), aFullFrameSize);
+ }
+ return iOuterRect;
+ }
+
+TRect CAlfSkinFrameItemImageLoader::AdjustedInnerRect(const TSize& aFullFrameSize) const
+ {
+ TRect adjustedOuterRect = AdjustedOuterRect(aFullFrameSize);
+ if (adjustedOuterRect != iOuterRect)
+ {
+ TInt adjustment = 0;
+
+ if ((adjustedOuterRect.Width() >= KSkinFrameBorderWidthDefaultValue * 2) &&
+ (adjustedOuterRect.Height() >= KSkinFrameBorderWidthDefaultValue * 2))
+ {
+ // Use default border width
+ adjustment = KSkinFrameBorderWidthDefaultValue;
+ }
+ else if ((adjustedOuterRect.Width() >= KSkinFrameBorderWidthSmallValue * 2) &&
+ (adjustedOuterRect.Height() >= KSkinFrameBorderWidthSmallValue * 2))
+ {
+ // Frame size is too small, use small border
+ adjustment = KSkinFrameBorderWidthSmallValue;
+ }
+ else if ((adjustedOuterRect.Width() >= KSkinFrameBorderWidthSmallestValue * 2) &&
+ (adjustedOuterRect.Height() >= KSkinFrameBorderWidthSmallestValue * 2))
+ {
+ // Frame size is too small, use smallest border
+ adjustment = KSkinFrameBorderWidthSmallestValue;
+ }
+ else
+ {
+ // Frame size is too small, just draw the center part
+ adjustment = 0;
+ }
+
+ adjustedOuterRect.iTl.iX += adjustment;
+ adjustedOuterRect.iBr.iX -= adjustment;
+ adjustedOuterRect.iTl.iY += adjustment;
+ adjustedOuterRect.iBr.iY -= adjustment;
+
+ return adjustedOuterRect;
+ }
+
+ return iInnerRect;
+ }
+
+
+CAlfAppIconImageLoader::CAlfAppIconImageLoader(
+ TUid aAppUid,
+ TAknsAppIconType aType):
+ iAppUid(aAppUid),
+ iType(aType)
+ {
+ }
+
+
+void CAlfAppIconImageLoader::ProvideBitmapL (
+ TInt aId,
+ CFbsBitmap *& aBitmap,
+ CFbsBitmap *& aMaskBitmap)
+ {
+ CAlfImageLoader::ProvideBitmapL (aId, aBitmap, aMaskBitmap);
+
+ AknsUtils::CreateAppIconLC(
+ GetValidSkinInstance(),
+ iAppUid, iType,
+ aBitmap, aMaskBitmap );
+
+ // Leave if bitmap or mask is NULL.
+ User::LeaveIfNull( aBitmap );
+ //User::LeaveIfNull( aMaskBitmap );
+
+ // diable compression so that the bitmap may be able to be duplicated inside
+ // AlfTK when BITGDI renderer is in use.
+ AknIconUtils::DisableCompression( aBitmap );
+
+ // Exclude from icon cache to avoid flooding it or to avoid bitmap sharing
+ if (iExcludeFromAvkonIconCache)
+ {
+ AknIconUtils::ExcludeFromCache( aBitmap );
+ }
+
+ // Set icon sizes and render them on the bitmaps.
+ // This does the actual rendering to specified size. (SVG -> bitmap)
+ AknIconUtils::SetSize( aBitmap, PreferredSize(aId), iScaleMode );
+
+ // pop the passed bitmap and mask
+ CleanupStack::Pop(2);
+ }
+
+EXPORT_C CAlfAutoSizeImageLoaderUtil::CAlfAutoSizeImageLoaderUtil()
+ {
+ }
+
+EXPORT_C TBool CAlfAutoSizeImageLoaderUtil::PreferredSizeChanged(const CAlfTexture& aChangedTexture, TSize aPreferredSize)
+ {
+ TBool ret = EFalse;
+ TInt count = iImageLoaderList.Count();
+ for (TInt i=0; i<count;i++)
+ {
+ ret |= iImageLoaderList[i]->PreferredSizeChanged(aChangedTexture, aPreferredSize);
+ }
+ return ret;
+ }