diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/coretoolkit/src/HuiImageLoaderUtil.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/coretoolkit/src/HuiImageLoaderUtil.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,410 @@ +/* +* Copyright (c) 2006-2007 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: Implements CHuiImageLoaderUtil, a utility to load skin-able image/icon. +* +*/ + + + +#include "uiacceltk/HuiImageLoaderUtil.h" +#include "uiacceltk/HuiBitmapProvider.h" +#include "uiacceltk/HuiTextureManager.h" +#include "uiacceltk/HuiStatic.h" +#include "uiacceltk/HuiEnv.h" + +struct THuiProvidedBitmap + { + TInt iId; + THuiRealSize iPreferredSize; + }; + +/** + * Base class of the image loder classes + */ +NONSHARABLE_CLASS(CHuiImageLoader): public CBase, public MHuiBitmapProvider, public MHuiTextureAutoSizeObserver + { +public: + CHuiImageLoader(); + + ~CHuiImageLoader(); + /** + * 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(const 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 CHuiTexture& aTexture, TInt aTextureId, const THuiRealSize& aPreferredSize); + + // From MHuiTextureAutoSizeObserver + virtual void PreferredSizeReportCompleted(); + +protected: + MAknsSkinInstance* GetValidSkinInstance(); + TSize PreferredSize(TInt aId); + +protected: + // common source info data + MAknsSkinInstance *iSkinInstance; + TSize iSize; + TScaleMode iScaleMode; + RArray iProvidedBitmaps; + }; + + +/** + * Image loader utility for skin item image loading. + * + */ +NONSHARABLE_CLASS(CHuiSkinItemImageLoader): public CHuiImageLoader +{ +public: + /** + * Construct an icon source information with Avkon skin item ID. AknsUtils::CreateIconL() + * will be called in RHuiImageLoaderUtil::CreateIconL(). + * + * @param aInstance Skin instance. + * @param aID An ID of the graphical item (e.g. an icon). + * @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. + */ + CHuiSkinItemImageLoader(const TAknsItemID &aID, const TDesC &aFileName, TInt aBitmapId, TInt aMaskId); + + /** + * Implementation of MHuiBitmapProvider 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: + TAknsItemID iId; + TPtrC iFileName; + TInt iBitmapId; + TInt iMaskId; +}; + + +/** + * Image loader utility for application icon loading. + * + */ +NONSHARABLE_CLASS(CHuiAppIconImageLoader): public CHuiImageLoader +{ +public: + /** + * Construct an icon source information to create application icon. AknsUtils::CreateAppIconLC() + * will be called in RHuiImageLoaderUtil::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... + */ + CHuiAppIconImageLoader(TUid aAppUid, TAknsAppIconType aType); + + /** + * Implementation of MHuiBitmapProvider 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 CHuiImageLoaderUtil::CHuiImageLoaderUtil() + :iSize(4,4), iScaleMode(EAspectRatioPreserved) + { + } + + +EXPORT_C CHuiImageLoaderUtil::~CHuiImageLoaderUtil() + { + for (TInt i=0; iSetSize(iSize); + imgLoader->SetScaleMode(iScaleMode); + imgLoader->SetSkinInstance(iSkinInstance); + iImageLoaderList.AppendL(imgLoader); + CleanupStack::Pop( imgLoader ); + return imgLoader; + } + + +EXPORT_C MHuiBitmapProvider* CHuiImageLoaderUtil::CreateImageLoaderL( + TUid aAppUid, + TAknsAppIconType aType) + { + CHuiAppIconImageLoader* imgLoader = new (ELeave) CHuiAppIconImageLoader( + 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 CHuiImageLoaderUtil::SetSize(TSize aSize, TScaleMode aMode) + { + iSize = aSize; + iScaleMode = aMode; + } + + +EXPORT_C void CHuiImageLoaderUtil::SetSkinInstance(MAknsSkinInstance *aSkinInstance) + { + iSkinInstance = aSkinInstance; + } + + + +// Image loaders +MAknsSkinInstance* CHuiImageLoader::GetValidSkinInstance() + { + if (iSkinInstance == NULL && CCoeEnv::Static()) + { + return AknsUtils::SkinInstance(); + } + else + { + return iSkinInstance; + } + } + +TBool CHuiImageLoader::PreferredSizeChanged(const CHuiTexture& /*aTexture*/, TInt aTextureId, const THuiRealSize& aPreferredSize) { + for(TInt ii = 0; ii < iProvidedBitmaps.Count(); ii++) + { + if (iProvidedBitmaps[ii].iId == aTextureId) + { + iProvidedBitmaps[ii].iPreferredSize = aPreferredSize; + return ETrue; + } + } + return EFalse; + } + +void CHuiImageLoader::PreferredSizeReportCompleted() + { + // Nothing to do + } + +void CHuiImageLoader::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. + THuiProvidedBitmap providedBitmap; + providedBitmap.iId = aId; + providedBitmap.iPreferredSize = iSize; + iProvidedBitmaps.AppendL(providedBitmap); + } + +CHuiImageLoader::CHuiImageLoader():iSize(4,4), iScaleMode(EAspectRatioPreserved) + { + } + +CHuiImageLoader::~CHuiImageLoader() + { + iProvidedBitmaps.Close(); + }; + +TSize CHuiImageLoader::PreferredSize(TInt aId) + { + for(TInt i = 0; i < iProvidedBitmaps.Count(); i++) + { + if (iProvidedBitmaps[i].iId == aId) + { + // Already in list, do nothing + return iProvidedBitmaps[i].iPreferredSize; + } + } + return iSize; + } + + +CHuiSkinItemImageLoader::CHuiSkinItemImageLoader( + const TAknsItemID &aID, + const TDesC &aFileName, + TInt aBitmapId, + TInt aMaskId): + iId(aID), + iBitmapId(aBitmapId), + iMaskId(aMaskId) + { + iFileName.Set(aFileName); + } + + +void CHuiSkinItemImageLoader::ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) + { + CHuiImageLoader::ProvideBitmapL( aId, aBitmap, aMaskBitmap); + MAknsSkinInstance* skininstance = GetValidSkinInstance(); + + if (skininstance) + { + TRAPD(err, AknsUtils::CreateIconL( + skininstance, iId, + aBitmap, aMaskBitmap, + iFileName, iBitmapId, iMaskId);); + if (err == KErrNotFound) + { + AknsUtils::CreateIconL(skininstance, + iId, + aBitmap, + iFileName, + iBitmapId ); + } + else + { + User::LeaveIfError(err); + } + } + else // proxy from other process + { + CHuiStatic::GetMaskedBitmapL(iId, + aBitmap, aMaskBitmap, iFileName, iBitmapId, iMaskId, PreferredSize(aId), iScaleMode ); + return; + } + + + // 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 + // HUITK when BITGDI renderer is in use. +#ifndef __SERIES60_30__ + AknIconUtils::DisableCompression( aBitmap ); +#else +#pragma message ("S60R30: FBS Compression can't be disabled, graphics may look crappy, deal with it") +#endif + + // 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 ); + } + + +CHuiAppIconImageLoader::CHuiAppIconImageLoader( + TUid aAppUid, + TAknsAppIconType aType): + iAppUid(aAppUid), + iType(aType) + { + } + + +void CHuiAppIconImageLoader::ProvideBitmapL ( + TInt aId, + CFbsBitmap *& aBitmap, + CFbsBitmap *& aMaskBitmap) + { + CHuiImageLoader::ProvideBitmapL( aId, aBitmap, aMaskBitmap); + MAknsSkinInstance* skin = GetValidSkinInstance(); + if (skin) + { + AknsUtils::CreateAppIconLC( + skin, + 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 + // HUITK when BITGDI renderer is in use. +#ifndef __SERIES60_30__ + AknIconUtils::DisableCompression( aBitmap ); +#else +#pragma message ("S60R30: FBS Compression can't be disabled, graphics may look crappy, deal with it") +#endif + + // 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 void CHuiImageLoaderUtil::ImageLoaderExtension(const TUid& /*aExtensionUid*/, TAny** /*aExtensionParamters*/ ) + { + + } + +EXPORT_C TBool CHuiAutoSizeImageLoaderUtil::PreferredSizeChanged(const CHuiTexture& aTexture, TInt aTextureId, const THuiRealSize& aPreferredSize) + { + TBool ret = EFalse; + TInt count = iImageLoaderList.Count(); + for (TInt i=0; iPreferredSizeChanged(aTexture, aTextureId, aPreferredSize); + } + return ret; + + } + +EXPORT_C void CHuiAutoSizeImageLoaderUtil::PreferredSizeReportCompleted() + { + // Do nothing + }