diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/Client/src/alfimageloaderutil.cpp --- /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 +#include +#include +#include + +#include + +// 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 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; iConstructL( 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 (&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(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; iPreferredSizeChanged(aChangedTexture, aPreferredSize); + } + return ret; + }