--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/skins/AknSkins/src/AknsDrawUtils.cpp Thu Dec 17 09:14:12 2009 +0200
@@ -0,0 +1,1336 @@
+/*
+* Copyright (c) 2002-2008 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: Drawing utility class.
+*
+*/
+
+
+// INCLUDE FILES
+#include "AknsCppPreface.h"
+
+#include <coecntrl.h>
+#include <w32std.h>
+#include <AknStatuspaneUtils.h>
+#include "layoutmetadata.cdl.h"
+#include "AknsDrawUtils.h"
+
+#include "AknsItemData.h"
+#include <AknsSkinInstance.h>
+#include <AknsControlContext.h>
+#include "AknsBackgroundLayout.h"
+#include <AknsImageAttributeData.h>
+#include "AknsAppSkinInstance.h"
+#include "AknsTemporaryBitmap.h"
+#include "AknsScalabilityUtils.h"
+#include <AknsLayeredBackgroundControlContext.h>
+#include "AknsMaskedLayerBackgroundControlContext.h"
+#include "AknsRlMasterLayout.h"
+#include "AknsRlUtils.h"
+
+
+#include "AknSkinsVariant.hrh"
+
+#include "AknsDebug.h"
+
+#ifdef RD_SLIDING_ANIMATION_EFFECTS
+_LIT(KAknsDrawUtilsSLDisabled,"ds");
+_LIT(KAknsDrawUtilsSLFromCBA ,"cba");
+_LIT(KAknsDrawUtilsSLFromL, "l");
+_LIT(KAknsDrawUtilsSLFromTL, "tl");
+_LIT(KAknsDrawUtilsSLFromT, "t");
+_LIT(KAknsDrawUtilsSLFromTR, "tr");
+_LIT(KAknsDrawUtilsSLFromR, "r");
+_LIT(KAknsDrawUtilsSLFromBR, "br");
+_LIT(KAknsDrawUtilsSLFromB, "b");
+_LIT(KAknsDrawUtilsSLFromBl, "bl");
+_LIT(KAknsDrawUtilsSLRnd, "rnd");
+#endif
+AKNS_UNDEFINED_METHOD(AknsDrawUtils::AknsDrawUtils)
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// IsSinglePart
+//
+// Checks whether the given item is a single-part image (bitmap or masked bitmap)
+//
+// Returns: ETrue or EFalse
+// -----------------------------------------------------------------------------
+//
+static TBool IsSinglePart(
+ MAknsSkinInstance* aInstance, const TAknsItemID& aIID )
+ {
+ CAknsItemData* fdata = aInstance->GetCachedItemData(
+ aIID, EAknsITBitmap );
+ if( fdata )
+ {
+ if( fdata->Type()==EAknsITBitmap
+ || fdata->Type()==EAknsITMaskedBitmap )
+ {
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// RetrieveKnownBackgroundImage
+//
+// Retrieves background image item data that has a known item ID (if any)
+//
+// Returns: Pointer to cached background image, or NULL
+// if none found.
+// -----------------------------------------------------------------------------
+//
+static CAknsImageItemData* RetrieveKnownBackgroundImage(
+ MAknsSkinInstance* aInstance,
+ const TAknsItemID& aIID, const TAknsBackground* aLayout = NULL )
+ {
+ if( !aInstance || aIID == KAknsIIDDefault || aIID == KAknsIIDNone )
+ {
+ return NULL;
+ }
+
+ TAknsItemID id = aIID;
+
+ // special handling for main panes
+ if (aIID == KAknsIIDQsnBgAreaMain ||
+ aIID == KAknsIIDQsnBgAreaMainListGene ||
+ aIID == KAknsIIDQsnBgAreaMainListSet ||
+ aIID == KAknsIIDQsnBgAreaMainMessage)
+ {
+ if (AknStatuspaneUtils::FlatLayoutActive())
+ {
+ id = KAknsIIDQsnBgAreaMainFlat;
+ }
+ else if (AknStatuspaneUtils::SmallLayoutActive())
+ {
+ id = KAknsIIDQsnBgAreaMainSmall;
+ }
+ }
+
+ // Special handling for popup centerpieces
+ if( AknsRlUtils::IsPopupCenter( id )
+ && IsSinglePart( aInstance, KAknsIIDQsnFrPopup ) )
+ {
+ // Frame exists and is not image table, return surrounding frame
+ return static_cast<CAknsImageItemData*>(
+ aInstance->GetCachedItemData( KAknsIIDQsnFrPopup, EAknsITImage ) );
+ }
+
+ CAknsItemData* idata = aInstance->GetCachedItemData( id ); //lint !e613 Always non-null
+
+ if( idata && AknsUtils::IsDerivedType( EAknsITImage, idata->Type()) )
+ {
+ return static_cast<CAknsImageItemData*>(idata);
+ }
+ // Render only if...
+ TBool doScalableRendering( EFalse );
+
+ CAknsAppSkinInstance* appSkinInstance =
+ static_cast<CAknsAppSkinInstance*>(aInstance);
+ if( idata )
+ {
+ if( AknsUtils::IsDerivedType( EAknsITEffectQueue, idata->Type() ) )
+ {
+ // ... 1) data exists and is an effect queue or...
+ doScalableRendering = ETrue;
+ }
+ else if( AknsUtils::IsDerivedType( EAknsITAnimation, idata->Type() ) )
+ {
+ CAknsAnimationItemData* adata =
+ static_cast<CAknsAnimationItemData*>( idata );
+ if( adata->Morphing() )
+ {
+ // ... 2) data exists and is a morphing animation element...
+ doScalableRendering = ETrue;
+ }
+ }
+ }
+ else
+ {
+ if( (appSkinInstance->MasterLayout()->GetParent(id) != KAknsIIDDefault) )
+ {
+ // ...or data does not exist and there is a (definite, but possibly
+ // non-existing) parent.
+ doScalableRendering = ETrue;
+ }
+ }
+
+ if( doScalableRendering )
+ {
+ return AknsScalabilityUtils::ConvertToBitmap(appSkinInstance, id, aLayout);
+ }
+
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// RetrieveBackgroundImage
+//
+// Retrieves background image item data (if any)
+//
+// Returns: Pointer to cached background image, or NULL
+// if none found.
+// -----------------------------------------------------------------------------
+//
+static CAknsImageItemData* RetrieveBackgroundImage(
+ MAknsSkinInstance* aInstance,
+ const TAknsBackground* aLayout, TAknsItemID& aIID )
+ {
+ aIID = aLayout ? aLayout->iImageID : KAknsIIDNone;
+ return RetrieveKnownBackgroundImage( aInstance, aIID, aLayout );
+ }
+
+// -----------------------------------------------------------------------------
+// RetrieveBackgroundLayout
+//
+// Retrieves pointer (not owned) to background layout.
+//
+// Returns: Pointer to background layout, or NULL
+// if none found.
+// -----------------------------------------------------------------------------
+//
+static TAknsBackground* RetrieveBackgroundLayout(
+ MAknsControlContext* aContext )
+ {
+ if( aContext )
+ {
+ return static_cast<TAknsBackground*>(
+ aContext->SupplySkinObject( EAknsCCOBackground ) );
+ }
+
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// GetParentAbsoluteDelta
+//
+// Calculates position delta based on parent absolute layout.
+// -----------------------------------------------------------------------------
+//
+static TPoint GetParentAbsoluteDelta(
+ const TAknsBackground* aLayout,
+ const CCoeControl* aControl )
+ {
+ TPoint p(0,0);
+
+ if( aLayout && aLayout->iParentAbsolute && aControl )
+ {
+ TPoint cachedPos;
+ if( AknsUtils::GetControlPosition( aControl, cachedPos ) == KErrNone )
+ {
+ p = cachedPos;
+ }
+ else
+ {
+ __ASSERT_DEBUG( aControl->DrawableWindow(),
+ AKNS_DEBUG_PANIC(EAknsDPanicNoWindow) );
+
+ // For release build, play it safe
+ if( !aControl->DrawableWindow() )
+ {
+ return p;
+ }
+
+ p = aControl->PositionRelativeToScreen();
+ }
+
+ if( !aControl->OwnsWindow() )
+ {
+ p -= aControl->Position();
+ }
+
+ p -= aLayout->iParentPos;
+ }
+
+ return p;
+ }
+
+// -----------------------------------------------------------------------------
+// DrawPartialCachedImage
+//
+// Draws the specified part of an image with layout.
+//
+// -----------------------------------------------------------------------------
+//
+static TBool DrawPartialCachedImage(
+ MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgLayoutRect,
+ const TRect& aTrgDrawRect, CAknsImageItemData* aImgData,
+ const TAknsItemID& aIID, const TAknsImageAttributeData* aAttr,
+ const TInt aDrawParam )
+ {
+ TRect trgLayoutRect( aTrgLayoutRect );
+
+ // Adjust "faked" centerpiece region
+ if( AknsRlUtils::IsPopupCenter(aIID)
+ && IsSinglePart( aSkin, KAknsIIDQsnFrPopup ) )
+ {
+ TSize tl, br;
+ AknsRlUtils::GetPopupFrameDimensions( tl, br );
+
+ trgLayoutRect.iTl -= tl;
+ trgLayoutRect.iBr += br;
+ }
+
+ return AknsScalabilityUtils::DrawPartialCachedImage( aSkin, aGc, trgLayoutRect,
+ aTrgDrawRect, aImgData, aIID, aAttr, aDrawParam );
+ }
+
+static TBool IsBackgroundItem( const TAknsItemID& aIID,CAknsAppSkinInstance* aSkin )
+ {
+ TBool isbg = EFalse;
+
+ if( aIID.iMajor == EAknsMajorSkin)
+ {
+ switch (aIID.iMinor)
+ {
+ case EAknsMinorQsnBgScreen:
+ case EAknsMinorQsnBgScreenIdle:
+ case EAknsMinorQsnBgScreenMp:
+ case EAknsMinorQsnBgAreaMain:
+ case EAknsMinorQsnBgAreaMainAppsGrid:
+ case EAknsMinorQsnBgAreaMainListGene:
+ case EAknsMinorQsnBgAreaMainListSet:
+ case EAknsMinorQsnBgAreaMainMessage:
+ case EAknsMinorQsnBgAreaMainHigh:
+ case EAknsMinorQsnBgAreaMainCalc:
+ case EAknsMinorQsnBgAreaMainPinb:
+ case EAknsMinorQsnBgAreaMainQdial:
+ case EAknsMinorQsnBgAreaMainMp:
+ case EAknsMinorQsnBgAreaMainFlat:
+ case EAknsMinorQsnBgAreaMainSmall:
+ case EAknsMinorQsnBgAreaMainIdle:
+ case EAknsMinorQsnBgAreaMainIdleDimmed:
+ case EAknsMinorQsnBgAreaStatus:
+ case EAknsMinorQsnBgAreaStatusIdle:
+ case EAknsMinorQsnBgAreaStaconRt:
+ case EAknsMinorQsnBgAreaStaconLt:
+ case EAknsMinorQsnBgAreaStaconRb:
+ case EAknsMinorQsnBgAreaStaconLb:
+ case EAknsMinorQsnBgAreaStaconRtIdle:
+ case EAknsMinorQsnBgAreaStaconLtIdle:
+ case EAknsMinorQsnBgAreaStaconRbIdle:
+ case EAknsMinorQsnBgAreaStaconLbIdle:
+ case EAknsMinorQsnBgAreaControl:
+ case EAknsMinorQsnBgAreaControlPopup:
+ case EAknsMinorQsnBgAreaControlMp:
+ case EAknsMinorQsnBgAreaControlIdle:
+ case EAknsMinorQsnBgColumn0:
+ case EAknsMinorQsnBgColumnA:
+ case EAknsMinorQsnBgColumnAB:
+ case EAknsMinorQsnBgColumnC0:
+ case EAknsMinorQsnBgColumnCA:
+ case EAknsMinorQsnBgColumnCAB:
+ case EAknsMinorQsnBgSliceList0:
+ case EAknsMinorQsnBgSliceListA:
+ case EAknsMinorQsnBgSliceListAB:
+ isbg = ETrue;
+ break;
+ case EAknsMinorWallpaper:
+ {
+ if ( aSkin && !aSkin->WallpaperDefined() )
+ {
+ isbg = ETrue;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ else if (aIID.iMajor == EAknsMajorAvkon)
+ {
+ switch (aIID.iMinor)
+ {
+ case EAknsMinorQsnBgNavipaneSolid:
+ case EAknsMinorQsnBgNavipaneWipe:
+ case EAknsMinorQsnBgNavipaneSolidIdle:
+ case EAknsMinorQsnBgNavipaneWipeIdle:
+ isbg = ETrue;
+ default:
+ break;
+ }
+ }
+ return isbg;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Blit
+//
+// Blits given image to gc.
+//
+// -----------------------------------------------------------------------------
+//
+inline static TBool Blit(
+ MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgRect,
+ CAknsImageItemData* aImgData, const TAknsItemID& aIID,
+ const TAknsBackground* aLayout, const TPoint& aPADelta,
+ const TInt aDrawParam )
+ {
+ CAknsAppSkinInstance* appInstance =
+ static_cast<CAknsAppSkinInstance*>(aSkin);
+
+ if ( IsBackgroundItem( aIID,appInstance ) &&
+ appInstance && appInstance->AnimBackgroundState() )
+ {
+ if( (aDrawParam&KAknsDrawParamPrepareOnly) )
+ {
+ return ETrue;
+ }
+
+ TRgb color = KRgbWhite;
+ color.SetAlpha(0x00);
+ aGc.SetPenColor(color);
+ aGc.SetBrushColor(color);
+ aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
+ TRect layoutRect( aTrgRect );
+ if( aLayout )
+ {
+ layoutRect = aLayout->iRect;
+ }
+ layoutRect.Move( -aPADelta );
+
+ TRect drawRect = aTrgRect;
+ drawRect.Intersection( layoutRect );
+
+ aGc.Clear(drawRect);
+ return ETrue;
+ }
+
+ TRect layoutRect( aTrgRect );
+
+ const TAknsImageAttributeData* attr = NULL;
+
+ if( aLayout )
+ {
+ layoutRect = aLayout->iRect;
+
+ if( aLayout->iAttr.iAttributes != EAknsImageAttributeNone )
+ {
+ attr = &(aLayout->iAttr);
+ }
+ }
+
+ layoutRect.Move( -aPADelta );
+
+ TRect drawRect(aTrgRect);
+ drawRect.Intersection( layoutRect );
+
+ return DrawPartialCachedImage( aSkin, aGc, layoutRect, drawRect,
+ aImgData, aIID, attr, aDrawParam );
+ }
+
+// -----------------------------------------------------------------------------
+// BlitAndClear
+//
+// Blits given image to gc and draws the area that is not
+// covered by the bitmap.
+//
+// -----------------------------------------------------------------------------
+//
+inline static TBool BlitAndClear(
+ MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgRect,
+ CAknsImageItemData* aImgData, const TAknsItemID& aIID,
+ const TAknsBackground* aLayout, const TPoint& aPADelta,
+ const TInt aDrawParam )
+ {
+ CAknsAppSkinInstance* appInstance =
+ static_cast<CAknsAppSkinInstance*>(aSkin);
+
+ if ( IsBackgroundItem( aIID,appInstance ) &&
+ appInstance && appInstance->AnimBackgroundState() )
+ {
+ return Blit( aSkin, aGc, aTrgRect, aImgData, aIID, aLayout, aPADelta, aDrawParam );
+ }
+
+ if( !(aDrawParam & KAknsDrawParamPrepareOnly) )
+ {
+ TAknsItemType type = aImgData->Type();
+ // don't clear if the item is not a masked one
+ if( AknsUtils::IsDerivedType( EAknsITMaskedBitmap, type )
+ && !(aDrawParam & KAknsDrawParamNoClearUnderImage) )
+ {
+ TRect layoutRect( aTrgRect );
+ if( aLayout )
+ {
+ layoutRect = aLayout->iRect;
+ }
+ layoutRect.Move( -aPADelta );
+
+ TRect drawRect(aTrgRect);
+ drawRect.Intersection( layoutRect );
+
+ aGc.DrawRect( drawRect );
+ }
+ }
+ return Blit( aSkin, aGc, aTrgRect, aImgData, aIID, aLayout, aPADelta, aDrawParam );
+ }
+
+// -----------------------------------------------------------------------------
+// CheckAndDrawCachedImage
+//
+// -----------------------------------------------------------------------------
+//
+static TBool CheckAndDrawCachedImage( MAknsSkinInstance* aSkin,
+ CBitmapContext& aGc, const TRect& aRect, const TAknsItemID& aIID,
+ const TInt aDrawParam )
+ {
+ // Basic consistency checks
+ if( !aSkin )
+ {
+ return EFalse;
+ }
+
+ CAknsItemData* data = aSkin->GetCachedItemData( aIID );
+ if( !data )
+ {
+ return EFalse;
+ }
+
+ if( !AknsUtils::IsDerivedType( EAknsITImage, data->Type() ) )
+ {
+ return EFalse;
+ }
+
+ return DrawPartialCachedImage( aSkin, aGc, aRect, aRect,
+ static_cast<CAknsImageItemData*>(data), aIID,
+ NULL, aDrawParam );
+ }
+
+// -----------------------------------------------------------------------------
+// GetParentContext
+//
+// -----------------------------------------------------------------------------
+//
+static MAknsControlContext* GetParentContext( MAknsControlContext* aContext )
+ {
+ if( aContext )
+ {
+ return static_cast<MAknsControlContext*>(
+ aContext->SupplySkinObject( EAknsCCOParentContext ) );
+ }
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CheckAndDrawFrame
+//
+// -----------------------------------------------------------------------------
+//
+static TBool CheckAndDrawFrame( MAknsSkinInstance* aInstance,
+ CBitmapContext& aGc, const TRect& aOuterRect, const TRect& aInnerRect,
+ const TAknsItemID& aFrameID, const TAknsItemID& aCenterID,
+ const TInt aDrawParam )
+ {
+ if( !aInstance )
+ {
+ return EFalse;
+ }
+
+ if( !(aDrawParam & KAknsDrawParamPrepareOnly) )
+ {
+ // Prepare before drawing
+ CheckAndDrawFrame( aInstance, aGc, aOuterRect, aInnerRect,
+ aFrameID, aCenterID, aDrawParam|KAknsDrawParamPrepareOnly );
+ }
+
+ CAknsImageItemData* rawData = static_cast<CAknsImageItemData*>(
+ aInstance->GetCachedItemData( aFrameID, EAknsITImage ) );
+ if( !rawData )
+ {
+ return EFalse;
+ }
+
+ if (!(aDrawParam & KAknsDrawParamPrepareOnly))
+ {
+ aGc.SetPenStyle(CGraphicsContext::ENullPen);
+ aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
+ }
+
+ TBool retVal = EFalse;
+
+ if( AknsUtils::IsDerivedType( EAknsITImageTable, rawData->Type() ) )
+ {
+ CAknsImageTableItemData* data =
+ static_cast<CAknsImageTableItemData*>(rawData);
+ if( data->NumberOfImages() != EAknsFrameElementsN )
+ {
+ return EFalse;
+ }
+
+ // Corners
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc,
+ TRect( aOuterRect.iTl, aInnerRect.iTl ),
+ data->ImageIID( EAknsFrameIndexTl ), aDrawParam );
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc,
+ TRect( aInnerRect.iBr.iX, aOuterRect.iTl.iY,
+ aOuterRect.iBr.iX, aInnerRect.iTl.iY ),
+ data->ImageIID( EAknsFrameIndexTr ), aDrawParam );
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc,
+ TRect( aOuterRect.iTl.iX, aInnerRect.iBr.iY,
+ aInnerRect.iTl.iX, aOuterRect.iBr.iY ),
+ data->ImageIID( EAknsFrameIndexBl ), aDrawParam );
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc,
+ TRect( aInnerRect.iBr, aOuterRect.iBr ),
+ data->ImageIID( EAknsFrameIndexBr ), aDrawParam );
+
+ // Sides
+ TRect sideRect( aInnerRect.iTl.iX, aOuterRect.iTl.iY,
+ aInnerRect.iBr.iX, aInnerRect.iTl.iY );
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,
+ data->ImageIID( EAknsFrameIndexT ), aDrawParam );
+ sideRect.SetRect( aInnerRect.iTl.iX, aInnerRect.iBr.iY,
+ aInnerRect.iBr.iX, aOuterRect.iBr.iY );
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,
+ data->ImageIID( EAknsFrameIndexB ), aDrawParam );
+ sideRect.SetRect( aOuterRect.iTl.iX, aInnerRect.iTl.iY,
+ aInnerRect.iTl.iX, aInnerRect.iBr.iY );
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,
+ data->ImageIID( EAknsFrameIndexL ), aDrawParam );
+ sideRect.SetRect( aInnerRect.iBr.iX, aInnerRect.iTl.iY,
+ aOuterRect.iBr.iX, aInnerRect.iBr.iY );
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,
+ data->ImageIID( EAknsFrameIndexR ), aDrawParam );
+
+ // Center
+ //lint --e{961} Valid logic
+ if( aCenterID == KAknsIIDDefault )
+ {
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc, aInnerRect,
+ data->ImageIID( EAknsFrameIndexCenter ), aDrawParam );
+ }
+ else if( aCenterID != KAknsIIDNone )
+ {
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc, aInnerRect,
+ aCenterID, aDrawParam );
+ }
+ }
+ else if( AknsUtils::IsDerivedType( EAknsITBitmap, rawData->Type() ) )
+ {
+ // Center only
+ retVal |= CheckAndDrawCachedImage( aInstance, aGc, aOuterRect,
+ aFrameID, aDrawParam );
+ }
+
+ if (!(aDrawParam & KAknsDrawParamPrepareOnly))
+ {
+ aGc.SetPenStyle(CGraphicsContext::ESolidPen); //lint !e961 Intentional
+ aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
+ }
+ return retVal;
+ }
+
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::ControlContext()
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::ControlContext)
+EXPORT_C MAknsControlContext* AknsDrawUtils::ControlContext(
+ const MObjectProvider* aMop )
+ {
+ MAknsControlContext* cc = NULL;
+ if( aMop )
+ {
+ const_cast<MObjectProvider*>(aMop)->MopGetObject( cc );
+ }
+
+ return cc;
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::ControlContextOfParent()
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::ControlContextOfParent)
+EXPORT_C MAknsControlContext* AknsDrawUtils::ControlContextOfParent(
+ const CCoeControl* aControl )
+ {
+ MObjectProvider* parentMop = NULL;
+ if( aControl )
+ {
+ // Bypass private qualifier of iMopParent member of CCoeControl
+ const TUint8* mopParentPointerLocation =
+ reinterpret_cast<const TUint8*>(aControl);
+ mopParentPointerLocation += sizeof( CCoeControl );
+ mopParentPointerLocation -= sizeof( MObjectProvider* );
+ TInt mopParentPointer =
+ *reinterpret_cast<const TInt*>( mopParentPointerLocation ); //lint !e826 Intentionally ugly
+ // Check alignment
+ __ASSERT_DEBUG( !(mopParentPointer&3),
+ AKNS_DEBUG_PANIC(EAknsDPanicBadAlignment));
+ parentMop = reinterpret_cast<MObjectProvider*>(
+ mopParentPointer );
+ }
+
+ return ControlContext( parentMop );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::Background()
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::Background)
+EXPORT_C TBool AknsDrawUtils::Background( MAknsSkinInstance* aInstance,
+ MAknsControlContext* aContext, CWindowGc& aGc, const TRect& aRect )
+ {
+ return Background( aInstance, aContext, NULL, aGc, aRect );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::Background()
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool AknsDrawUtils::Background( MAknsSkinInstance* aInstance,
+ MAknsControlContext* aContext, const CCoeControl* aControl,
+ CWindowGc& aGc, const TRect& aRect )
+ {
+ return Background( aInstance, aContext, aControl, aGc, aRect,
+ KAknsDrawParamDefault );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::Background()
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool AknsDrawUtils::Background( MAknsSkinInstance* aInstance,
+ MAknsControlContext* aContext, const CCoeControl* aControl,
+ CWindowGc& aGc, const TRect& aRect, const TInt aDrawParam )
+ {
+ return DrawBackground( aInstance, aContext, aControl,
+ aGc, aRect.iTl, aRect, aDrawParam );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::DrawBackground()
+// (commented in the header).
+// -----------------------------------------------------------------------------
+EXPORT_C TBool AknsDrawUtils::DrawBackground( MAknsSkinInstance* aInstance,
+ MAknsControlContext* aContext, const CCoeControl* aControl,
+ CBitmapContext& aGc, const TPoint& aDstPos,
+ const TRect& aControlRect, const TInt aDrawParam )
+ {
+ TInt drawParam = aDrawParam;
+ TInt originalParam = aDrawParam;
+ TBool retVal = EFalse;
+ TBool blitFailed = EFalse;
+ TBool blit = EFalse;
+ TBool blitAttempted = EFalse;
+
+ if ( !&aGc )
+ {
+ return retVal;
+ }
+
+ MAknsControlContext* parentContext = GetParentContext( aContext );
+ if( parentContext )
+ {
+ retVal = DrawBackground( aInstance, parentContext, aControl, aGc,
+ aDstPos, aControlRect, aDrawParam );
+ drawParam |= KAknsDrawParamNoClearUnderImage;
+ }
+ else if( drawParam & KAknsDrawParamBottomLevelRGBOnly )
+ {
+ drawParam |= KAknsDrawParamRGBOnly;
+ }
+
+ originalParam = drawParam;
+
+ if( aContext )
+ {
+ aContext->UpdateContext();
+ }
+
+ TAknsBackground* bgLayout = RetrieveBackgroundLayout( aContext );
+
+ TAknsItemID imgIID( KAknsIIDNone );
+ CAknsImageItemData* imgData = RetrieveBackgroundImage(
+ aInstance, bgLayout, imgIID );
+
+ // chained background
+ if (imgData && imgData->ParentIID() != KAknsIIDNone)
+ {
+ TAknsItemID parentiid = imgData->ParentIID();
+ TRect parentDrawRect = imgData->DrawRect();
+
+ imgData = RetrieveKnownBackgroundImage(
+ aInstance, parentiid );
+ if (imgData)
+ {
+ imgData->SetDrawRect(parentDrawRect);
+ drawParam |= KAknsDrawParamChained ;
+ }
+ }
+
+ TPoint paDelta = GetParentAbsoluteDelta( bgLayout, aControl );
+
+ TRect drawRect = aControlRect;
+ drawRect.Move( aDstPos-aControlRect.iTl );
+ paDelta += aControlRect.iTl-aDstPos;
+
+ if (!(aDrawParam & KAknsDrawParamPrepareOnly))
+ {
+ aGc.SetPenStyle(CGraphicsContext::ENullPen);
+ aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+ }
+
+ if ( !(aDrawParam & KAknsDrawParamIgnoreLayerMask))
+ {
+ if( imgData )
+ {
+ blitAttempted = ETrue;
+ if( (drawParam&KAknsDrawParamNoClearUnderImage)==0 )
+ {
+ blit = BlitAndClear( aInstance, aGc, drawRect,
+ imgData, imgIID, bgLayout, paDelta, drawParam );
+ }
+ else
+ {
+ blit = Blit( aInstance, aGc, drawRect,
+ imgData, imgIID, bgLayout, paDelta, drawParam );
+ }
+ if ( !blit )
+ {
+ blitFailed = ETrue;
+ }
+ }
+ else
+ {
+ if( !(drawParam&KAknsDrawParamNoClearUnderImage) &&
+ !(drawParam&KAknsDrawParamPrepareOnly) )
+ {
+ // Clear only if permitted
+ aGc.DrawRect( drawRect );
+ }
+ }
+ }
+
+ if( bgLayout )
+ {
+ if (!(aDrawParam & KAknsDrawParamIgnoreLayerMask) && aContext->IsCompatibleWithType(EAknsControlContextTypeMasked))
+ {
+ CAknsMaskedLayerBackgroundControlContext* layeredCxt = static_cast<CAknsMaskedLayerBackgroundControlContext*>(aContext);
+ if (layeredCxt->iOffScreenBmp)
+ {
+ CAknsMaskedBitmapItemData* maskedImgData = NULL;
+ TRAPD( err, maskedImgData = CAknsMaskedBitmapItemData::NewL() );
+ if ( err != KErrNone )
+ {
+ return EFalse;
+ }
+ maskedImgData->SetBitmap(layeredCxt->iOffScreenBmp);
+ maskedImgData->SetMask(layeredCxt->iLayerMask);
+
+ TAknsBackground* childLayout = bgLayout->iNext;
+
+ blitAttempted = ETrue;
+ blit = Blit( aInstance, aGc, drawRect, maskedImgData,
+ KAknsIIDNone, childLayout, paDelta, drawParam );
+ if ( !blit )
+ {
+ blitFailed = ETrue;
+ }
+
+ maskedImgData->SetBitmap(NULL);
+ maskedImgData->SetMask(NULL);
+ delete maskedImgData;
+ if (!(aDrawParam & KAknsDrawParamPrepareOnly))
+ {
+ aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
+ }
+ retVal = !blitFailed;
+ return retVal;
+ }
+ }
+
+ if (!aContext->IsCompatibleWithType(EAknsControlContextTypeFrame))
+ {
+ // special handling for frames
+ drawParam|=KAknsDrawParamNoClearUnderImage;
+ originalParam|=KAknsDrawParamNoClearUnderImage;
+ }
+ TAknsBackground* nextLayout = bgLayout->iNext;
+ while( nextLayout &&
+ ((drawParam & KAknsDrawParamLimitToFirstLevel) == 0) )
+ {
+ imgData = RetrieveKnownBackgroundImage( aInstance,
+ nextLayout->iImageID );
+ if (imgData && imgData->ParentIID() != KAknsIIDNone)
+ {
+ TAknsItemID parentiid = imgData->ParentIID();
+ TRect parentDrawRect = imgData->DrawRect();
+
+ imgData = RetrieveKnownBackgroundImage(
+ aInstance, parentiid );
+ if (imgData)
+ {
+ imgData->SetDrawRect(parentDrawRect);
+ drawParam |= KAknsDrawParamChained ;
+ }
+ }
+ else
+ {
+ drawParam=originalParam;
+ }
+ if( imgData )
+ {
+ blitAttempted = ETrue;
+ blit = BlitAndClear( aInstance, aGc, drawRect, imgData,
+ nextLayout->iImageID, nextLayout, paDelta, drawParam );
+ if ( !blit )
+ {
+ blitFailed = ETrue;
+ }
+ }
+ nextLayout = nextLayout->iNext;
+ }
+ }
+
+ if (!(aDrawParam & KAknsDrawParamPrepareOnly))
+ {
+ aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
+ }
+
+ // If Blit failed, or was not even attempted => return EFalse
+ if ( blitFailed )
+ {
+ retVal = EFalse;
+ }
+ else if ( !retVal )
+ {
+ retVal = blitAttempted;
+ }
+
+ return retVal;
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::BackgroundBetweenRects()
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::BackgroundBetweenRects)
+EXPORT_C TBool AknsDrawUtils::BackgroundBetweenRects(
+ MAknsSkinInstance* aInstance,
+ MAknsControlContext* aContext, CWindowGc& aGc,
+ const TRect& aOuterRect,const TRect& aInnerRect )
+ {
+ return BackgroundBetweenRects( aInstance, aContext, NULL, aGc, aOuterRect,
+ aInnerRect );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::BackgroundBetweenRects()
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool AknsDrawUtils::BackgroundBetweenRects(
+ MAknsSkinInstance* aInstance, MAknsControlContext* aContext,
+ const CCoeControl* aControl, CWindowGc& aGc,
+ const TRect& aOuterRect,const TRect& aInnerRect )
+ {
+ return BackgroundBetweenRects( aInstance, aContext, aControl, aGc,
+ aOuterRect, aInnerRect, KAknsDrawParamDefault );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::BackgroundBetweenRects()
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool AknsDrawUtils::BackgroundBetweenRects(
+ MAknsSkinInstance* aInstance, MAknsControlContext* aContext,
+ const CCoeControl* aControl, CWindowGc& aGc,
+ const TRect& aOuterRect,const TRect& aInnerRect, const TInt aDrawParam )
+ {
+ TInt drawParam = aDrawParam;
+ TInt originalParam = aDrawParam;
+ TBool retVal = EFalse;
+ TBool blitFailed = EFalse;
+ TBool blitAttempted = EFalse;
+
+ if ( !&aGc )
+ {
+ return retVal;
+ }
+
+ MAknsControlContext* parentContext = GetParentContext( aContext );
+ if( parentContext )
+ {
+ retVal = BackgroundBetweenRects( aInstance, parentContext, aControl, aGc,
+ aOuterRect, aInnerRect, aDrawParam );
+ drawParam |= KAknsDrawParamNoClearUnderImage;
+ }
+ else if( drawParam & KAknsDrawParamBottomLevelRGBOnly )
+ {
+ drawParam |= KAknsDrawParamRGBOnly;
+ }
+
+ originalParam = drawParam;
+
+ if( aContext )
+ {
+ aContext->UpdateContext();
+ }
+
+ TAknsBackground* bgLayout = RetrieveBackgroundLayout( aContext );
+
+ TAknsItemID imgIID( KAknsIIDNone );
+ CAknsImageItemData* imgData = RetrieveBackgroundImage(
+ aInstance, bgLayout, imgIID );
+
+ // chained background
+ if (imgData && imgData->ParentIID() != KAknsIIDNone)
+ {
+ TAknsItemID parentiid = imgData->ParentIID();
+ TRect parentDrawRect = imgData->DrawRect();
+
+ imgData = RetrieveKnownBackgroundImage(
+ aInstance, parentiid );
+ if (imgData)
+ {
+ imgData->SetDrawRect(parentDrawRect);
+ drawParam |= KAknsDrawParamChained ;
+ }
+ }
+
+ TPoint paDelta = GetParentAbsoluteDelta( bgLayout, aControl );
+
+ if (!(aDrawParam & KAknsDrawParamPrepareOnly))
+ {
+ aGc.SetPenStyle(CGraphicsContext::ENullPen);
+ aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+ }
+
+ TBool blit = EFalse;
+ //Rect for frame border
+ TRect rlist[4];
+ rlist[0] = aOuterRect;
+ rlist[0].iBr.iY=aInnerRect.iTl.iY;
+ rlist[1] = rlist[0];
+ rlist[1].iBr.iY=aOuterRect.iBr.iY;
+ rlist[1].iTl.iY=aInnerRect.iBr.iY;
+ rlist[2] = aInnerRect;
+ rlist[2].iTl.iX=aOuterRect.iTl.iX;
+ rlist[2].iBr.iX=aInnerRect.iTl.iX;
+ rlist[3] = rlist[2];
+ rlist[3].iTl.iX=aInnerRect.iBr.iX;
+ rlist[3].iBr.iX=aOuterRect.iBr.iX;
+ if( imgData )
+ {
+ blitAttempted = ETrue;
+ for ( TInt i=0; i <4 ; i++ )
+ {
+ if( (drawParam & KAknsDrawParamNoClearUnderImage) == 0 )
+ {
+ blit = BlitAndClear( aInstance, aGc, rlist[i],
+ imgData, imgIID, bgLayout, paDelta, drawParam );
+ }
+ else
+ {
+ blit = Blit( aInstance, aGc, rlist[i],
+ imgData, imgIID, bgLayout, paDelta, drawParam );
+ }
+ if ( !blit )
+ {
+ blitFailed = ETrue;
+ }
+ }
+ }
+ else
+ {
+ if( !(drawParam & KAknsDrawParamNoClearUnderImage) &&
+ !(drawParam & KAknsDrawParamPrepareOnly) )
+ {
+ // Clear only if permitted
+ for (TInt i=0; i<4; i++)
+ {
+ aGc.DrawRect(rlist[i]);
+ }
+ }
+ }
+
+ if( bgLayout )
+ {
+ TAknsBackground* nextLayout = bgLayout->iNext;
+ while( nextLayout && (drawParam!=KAknsDrawParamLimitToFirstLevel) )
+ {
+ imgData = RetrieveKnownBackgroundImage( aInstance,
+ nextLayout->iImageID );
+ if (imgData && imgData->ParentIID() != KAknsIIDNone)
+ {
+ TAknsItemID parentiid = imgData->ParentIID();
+ TRect parentDrawRect = imgData->DrawRect();
+
+ imgData = RetrieveKnownBackgroundImage(
+ aInstance, parentiid );
+ if (imgData)
+ {
+ imgData->SetDrawRect(parentDrawRect);
+ drawParam |= KAknsDrawParamChained;
+ }
+ }
+ else
+ {
+ drawParam=originalParam;
+ }
+
+ if( imgData )
+ {
+ blitAttempted = ETrue;
+ for ( TInt i=0; i < 4; i++ )
+ {
+ blit = Blit( aInstance, aGc, rlist[i], imgData,
+ nextLayout->iImageID, nextLayout, paDelta, drawParam );
+ if ( !blit )
+ {
+ blitFailed = ETrue;
+ }
+ }
+ }
+
+ nextLayout = nextLayout->iNext;
+ }
+ }
+
+ if (!(aDrawParam & KAknsDrawParamPrepareOnly))
+ {
+ aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
+ }
+
+ if ( blitFailed )
+ {
+ retVal = EFalse;
+ }
+ else if ( !retVal )
+ {
+ retVal = blitAttempted;
+ }
+
+ return retVal;
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::HasBitmapBackground
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::HasBitmapBackground)
+EXPORT_C TBool AknsDrawUtils::HasBitmapBackground(
+ MAknsSkinInstance* /*aInstance*/, MAknsControlContext* /*aContext*/ )
+ {
+ return ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::DrawCachedImage
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::DrawCachedImage)
+EXPORT_C void AknsDrawUtils::DrawCachedImage( MAknsSkinInstance* aInstance,
+ CWindowGc& aGc, const TRect& aRect, const TAknsItemID& aID )
+ {
+ // Ignore return value
+ CheckAndDrawCachedImage( aInstance, aGc, aRect, aID, KAknsDrawParamDefault );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::DrawCachedImage
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::DrawCachedImage)
+EXPORT_C void AknsDrawUtils::DrawCachedImage( MAknsSkinInstance* aInstance,
+ CFbsBitGc& aGc, const TRect& aRect, const TAknsItemID& aID )
+ {
+ // Ignore return value
+ CheckAndDrawCachedImage( aInstance, aGc, aRect, aID, KAknsDrawParamDefault );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::PrepareFrame
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::PrepareFrame)
+EXPORT_C TBool AknsDrawUtils::PrepareFrame( MAknsSkinInstance* aInstance,
+ const TRect& aOuterRect, const TRect& aInnerRect,
+ const TAknsItemID& aFrameID, const TAknsItemID& aCenterID)
+ {
+ CBitmapContext* gc = NULL;
+ return CheckAndDrawFrame( aInstance, *gc, aOuterRect, aInnerRect,
+ aFrameID, aCenterID, KAknsDrawParamPrepareOnly );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::DrawFrame
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::DrawFrame)
+EXPORT_C TBool AknsDrawUtils::DrawFrame( MAknsSkinInstance* aInstance,
+ CWindowGc& aGc, const TRect& aOuterRect, const TRect& aInnerRect,
+ const TAknsItemID& aFrameID, const TAknsItemID& aCenterID )
+ {
+ return CheckAndDrawFrame( aInstance, aGc, aOuterRect, aInnerRect,
+ aFrameID, aCenterID, KAknsDrawParamDefault );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::DrawFrame
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::DrawFrame)
+EXPORT_C TBool AknsDrawUtils::DrawFrame( MAknsSkinInstance* aInstance,
+ CFbsBitGc& aGc, const TRect& aOuterRect, const TRect& aInnerRect,
+ const TAknsItemID& aFrameID, const TAknsItemID& aCenterID,
+ const TInt aDrawParam )
+ {
+ return CheckAndDrawFrame( aInstance, aGc, aOuterRect, aInnerRect,
+ aFrameID, aCenterID, aDrawParam );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::DrawFrame
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::DrawFrame)
+EXPORT_C TBool AknsDrawUtils::DrawFrame( MAknsSkinInstance* aInstance,
+ CFbsBitGc& aGc, const TRect& aOuterRect, const TRect& aInnerRect,
+ const TAknsItemID& aFrameID, const TAknsItemID& aCenterID )
+ {
+ return CheckAndDrawFrame( aInstance, aGc, aOuterRect, aInnerRect,
+ aFrameID, aCenterID, KAknsDrawParamDefault );
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::DrawFramePart
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+AKNS_EXPORTED_METHOD(AknsDrawUtils::DrawFramePart)
+EXPORT_C TBool AknsDrawUtils::DrawFramePart( MAknsSkinInstance* aInstance,
+ CWindowGc& aGc, const TRect& aRect, const TAknsItemID& aFrameID,
+ const TAknsFrameElementIndex aFrameElement )
+ {
+ if( !aInstance )
+ {
+ return EFalse;
+ }
+
+ CAknsImageTableItemData* data = static_cast<CAknsImageTableItemData*>(
+ aInstance->GetCachedItemData( aFrameID, EAknsITImageTable ) );
+ if( data && (data->NumberOfImages()==EAknsFrameElementsN) )
+ {
+ aGc.SetPenStyle(CGraphicsContext::ENullPen);
+ aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+
+ TBool retVal = CheckAndDrawCachedImage( aInstance, aGc, aRect,
+ data->ImageIID( aFrameElement ), KAknsDrawParamDefault );
+
+ aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+ aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
+
+ return retVal;
+ }
+
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::IsListSeperatorLines
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool AknsDrawUtils::IsListSeperatorLines(
+ MAknsSkinInstance* aInstance )
+ {
+ if ( !aInstance ) return ETrue;
+
+ TBool propVal = ETrue;
+ TRAPD( propErr, (propVal=AknsUtils::BooleanPropertyL(
+ aInstance, KAknsIIDPropertyListSeparatorLines )) );
+ if( !propErr ) return propVal;
+
+ if( AknsUtils::GetCachedBitmap(
+ aInstance, KAknsIIDQsnBgColumnA ) )
+ return EFalse;
+
+ if( AknsUtils::GetCachedBitmap(
+ aInstance, KAknsIIDQsnBgAreaMainListGene ) )
+ return EFalse;
+
+ return ETrue;
+ }
+
+
+// -----------------------------------------------------------------------------
+// AknsDrawUtils::SlidingMode
+// (commented in the header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TSlidingMode AknsDrawUtils::SlidingMode( MAknsSkinInstance*
+#ifdef RD_SLIDING_ANIMATION_EFFECTS
+ aInstance
+#endif // RD_SLIDING_ANIMATION_EFFECTS
+)
+ {
+#ifdef RD_SLIDING_ANIMATION_EFFECTS
+ if (!KAknsFeaSlideNotes || !aInstance)
+ {
+ return ESlidingDisabled;
+ }
+
+ CAknsStringItemData* data = static_cast<CAknsStringItemData*>(
+ aInstance->GetCachedItemData( KAknsIIDPropertyNoteSlidingMode, EAknsITString ) );
+ if( !data )
+ {
+ return ESlidingDisabled;
+ }
+
+ if( !data->String().CompareF( KAknsDrawUtilsSLDisabled ) ) return ESlidingDisabled;
+ if( !data->String().CompareF( KAknsDrawUtilsSLFromCBA ) ) return ESlidingFromCBA;
+ if( !data->String().CompareF( KAknsDrawUtilsSLFromL ) ) return ESlidingFromLeft;
+ if( !data->String().CompareF( KAknsDrawUtilsSLFromTL ) ) return ESlidingFromTopLeft;
+ if( !data->String().CompareF( KAknsDrawUtilsSLFromT ) ) return ESlidingFromTop;
+ if( !data->String().CompareF( KAknsDrawUtilsSLFromTR ) ) return ESlidingFromTopRight;
+ if( !data->String().CompareF( KAknsDrawUtilsSLFromR ) ) return ESlidingFromRight;
+ if( !data->String().CompareF( KAknsDrawUtilsSLFromBR ) ) return ESlidingFromBottomRight;
+ if( !data->String().CompareF( KAknsDrawUtilsSLFromB ) ) return ESlidingFromBottom;
+ if( !data->String().CompareF( KAknsDrawUtilsSLFromBl ) ) return ESlidingFromBottomLeft;
+ if( !data->String().CompareF( KAknsDrawUtilsSLRnd ) ) return ESlidingFromRandom;
+#endif //RD_SLIDING_ANIMATION_EFFECTS
+
+ return ESlidingDisabled; // Never reached when animations are on
+ }
+
+
+// End of File