--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/skins/AknSkins/rlsrc/AknsRlDefaultRenderer.cpp Thu Dec 17 09:14:12 2009 +0200
@@ -0,0 +1,475 @@
+/*
+* Copyright (c) 2004-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: Default renderer.
+*
+*/
+
+
+// INCLUDE FILES
+#include "AknsRlDefaultRenderer.h"
+
+#include "AknsRlInternalEffectPool.h"
+#include "AknSkinsVariant.hrh"
+#include "AknsDebug.h"
+#include <akniconconfig.h>
+
+// CONSTANTS
+
+static const TInt KAknsRlDefaultRendererLayerN = 3;
+
+// INTERNAL CLASSES
+
+NONSHARABLE_CLASS(CAknsRlDefaultEffectContext) :
+ public CBase, public MAknsRlEffectContext
+ {
+ public: // Constructor and destructor
+ CAknsRlDefaultEffectContext( const TSize aSize );
+ ~CAknsRlDefaultEffectContext();
+ void ConstructL();
+
+ public: // From MAknsRlEffectContext
+ const TSize LayerSize();
+ void GetLayerDataL( TAknsRlLayerData& aData,
+ const TInt aLayerIndex, const TInt aLayerStatus,
+ const TBool aInitialize );
+ RAknsSrvSession* GetSkinSrvSession();
+
+ public: // New methods
+ void DetachLayerBitmaps( const TInt aLayerIndex );
+ void SetSkinSrvSession(RAknsSrvSession* aSession);
+
+ private: // New methods
+ void CreateIfNeededL( const TInt aLayerIndex, const TInt aLayerStatus,
+ const TBool aInitialize );
+
+ private:
+ TSize iSize;
+ TAknsRlLayerData iLayers[KAknsRlDefaultRendererLayerN];
+ RAknsSrvSession* iSkinSrvSession;
+ };
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+TDisplayMode DefaultRenderingMode()
+{
+ AknIconConfig::TPreferredDisplayMode mode;
+ AknIconConfig::PreferredDisplayMode(mode, AknIconConfig::EImageTypeOffscreen);
+ return mode.iBitmapMode;
+}
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultRenderer::CAknsRlDefaultRenderer
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CAknsRlDefaultRenderer::CAknsRlDefaultRenderer(RAknsSrvSession* aSession)
+ : iSkinSrvSession(aSession)
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CAknsRlDefaultRenderer::~CAknsRlDefaultRenderer()
+ {
+ delete iPool;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultRenderer::NewL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CAknsRlDefaultRenderer* CAknsRlDefaultRenderer::NewL(
+ RAknsSrvSession* aSession )
+ {
+ CAknsRlDefaultRenderer* self =
+ new (ELeave) CAknsRlDefaultRenderer(aSession);
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop(); // self
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultRenderer::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CAknsRlDefaultRenderer::ConstructL()
+ {
+ iPool = CAknsRlInternalEffectPool::NewL();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultRenderer::RenderItem
+// -----------------------------------------------------------------------------
+//
+TInt CAknsRlDefaultRenderer::RenderItem(
+ CFbsBitmap*& aOutRGB, CFbsBitmap*& aOutAlpha,
+ const TInt aOutLayerIndex, MAknsRlCommandIterator* aCommands,
+ const TSize& aSize )
+ {
+ TInt ret = KErrNone;
+ TRAP( ret, DoRenderItemL( aOutRGB, aOutAlpha, aOutLayerIndex,
+ aCommands, aSize, NULL, NULL, TRect(0,0,1,1), -1 ) );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultRenderer::RenderItemWithBackground
+// -----------------------------------------------------------------------------
+//
+TInt CAknsRlDefaultRenderer::RenderItemWithBackground(
+ CFbsBitmap*& aOutRGB, CFbsBitmap*& aOutAlpha,
+ const TInt aOutLayerIndex,
+ MAknsRlCommandIterator* aCommands, const TSize& aSize,
+ const CFbsBitmap* aInRGB, const CFbsBitmap* aInAlpha,
+ const TRect& aInRect, const TInt aInLayerIndex )
+ {
+ TInt ret = KErrNone;
+ TRAP( ret, DoRenderItemL( aOutRGB, aOutAlpha, aOutLayerIndex,
+ aCommands, aSize, aInRGB, aInAlpha, aInRect, aInLayerIndex ) );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultRenderer::DisplayMode
+// -----------------------------------------------------------------------------
+//
+TDisplayMode CAknsRlDefaultRenderer::DisplayMode()
+ {
+ return DefaultRenderingMode();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultRenderer::DoRenderItemL
+// -----------------------------------------------------------------------------
+//
+void CAknsRlDefaultRenderer::DoRenderItemL(
+ CFbsBitmap*& aOutRGB, CFbsBitmap*& aOutAlpha,
+ const TInt aOutputLayerIndex,
+ MAknsRlCommandIterator* aCommands,
+ const TSize& aSize,
+ const CFbsBitmap* aInRGB, const CFbsBitmap* aInAlpha,
+ const TRect& aInRect, const TInt aInputLayerIndex )
+ {
+ CAknsRlDefaultEffectContext* context =
+ new (ELeave) CAknsRlDefaultEffectContext( aSize );
+ CleanupStack::PushL( context );
+ context->ConstructL();
+ context->SetSkinSrvSession(iSkinSrvSession);
+
+ if( aInputLayerIndex>=0 )
+ {
+ TInt inputMode = KAknsRlLayerNone;
+ if( aInRGB && aInAlpha ) inputMode = KAknsRlLayerRGBA;
+ else if( aInRGB ) inputMode = KAknsRlLayerRGBOnly;
+ else if( aInAlpha ) inputMode = KAknsRlLayerAlphaOnly;
+
+ TAknsRlLayerData inputLayer;
+ context->GetLayerDataL( inputLayer, aInputLayerIndex,
+ inputMode, ETrue );
+
+ if( inputLayer.iRGBGc ) inputLayer.iRGBGc->BitBlt(
+ TPoint(0,0), aInRGB, aInRect );
+ if( inputLayer.iAlphaGc ) inputLayer.iAlphaGc->BitBlt(
+ TPoint(0,0), aInAlpha, aInRect );
+ }
+
+ ExecuteCommandsL( aCommands, context );
+
+ TAknsRlLayerData outputLayer;
+ context->GetLayerDataL( outputLayer, aOutputLayerIndex,
+ KAknsRlLayerRGBA, ETrue );
+ aOutRGB = outputLayer.iRGBBitmap;
+ aOutAlpha = outputLayer.iAlphaBitmap;
+
+ context->DetachLayerBitmaps( aOutputLayerIndex );
+ // Output detached, no leaves allowed after this point
+
+ CleanupStack::PopAndDestroy( context );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultRenderer::ExecuteCommandsL
+// -----------------------------------------------------------------------------
+//
+void CAknsRlDefaultRenderer::ExecuteCommandsL(
+ MAknsRlCommandIterator* aCommands, MAknsRlEffectContext* aContext )
+ {
+ if( !aCommands ) return;
+
+ while( aCommands->HasNext() )
+ {
+ const TAknsRlCommandData* data = aCommands->NextL();
+
+ MAknsRlEffect* effect = iPool->GetEffect( data->iEffectUid );
+
+ if( !effect )
+ {
+ AKNS_TRACE_ERROR1("CAknsRlDefaultRenderer::ExecuteCommandsL Effect %x not available", data->iEffectUid );
+ User::Leave( KAknsRlErrEffectNotAvailable );
+ }
+
+ effect->ActivateL( aContext );
+ // CS: No untrapped leaves after this line before deactivation
+
+ if( data->iParamIterator )
+ {
+ TRAPD( paramErr, effect->SetParametersL( *data->iParamIterator ) );
+ if( paramErr )
+ {
+ effect->Deactivate();
+ AKNS_TRACE_ERROR1("CAknsRlDefaultRenderer::ExecuteCommandsL Bad parameters for effect %x", data->iEffectUid );
+ User::Leave( paramErr );
+ }
+ }
+
+ TAknsRlRenderOpParam opParam = data->iLayerConf;
+
+ TAknsRlEffectCaps caps;
+ effect->GetCapabilities( caps );
+
+ TBool opPossible = ETrue;
+ if( !(caps.iInputLayerASupport&opParam.iInputLayerAStatus) )
+ opPossible = EFalse;
+ if( !(caps.iInputLayerBSupport&opParam.iInputLayerBStatus) )
+ opPossible = EFalse;
+ if( !(caps.iOutputLayerSupport&opParam.iOutputLayerStatus) )
+ opPossible = EFalse;
+ if( opParam.iOutputLayerStatus == KAknsRlLayerNone )
+ opPossible = EFalse;
+
+ TInt effectRet = KErrArgument;
+
+ if( opPossible )
+ {
+ effectRet = KAknsRlRenderIncomplete;
+ while( effectRet == KAknsRlRenderIncomplete )
+ {
+ effectRet = effect->Render( opParam );
+ }
+ }
+#if defined(_DEBUG)
+ else
+ {
+ AKNS_TRACE_ERROR1("CAknsRlDefaultRenderer::ExecuteCommandsL Effect %x not executed", data->iEffectUid );
+ }
+#endif
+
+ // CS: Deactivation, leaves are OK after this
+ effect->Deactivate();
+
+#if defined(_DEBUG)
+ if( effectRet )
+ {
+ AKNS_TRACE_ERROR2("CAknsRlDefaultRenderer::ExecuteCommandsL Effect %x returned %i", data->iEffectUid, effectRet );
+ }
+#endif
+
+ User::LeaveIfError( effectRet );
+ }
+ }
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultEffectContext::CAknsRlDefaultEffectContext
+// -----------------------------------------------------------------------------
+//
+CAknsRlDefaultEffectContext::CAknsRlDefaultEffectContext(
+ const TSize aSize ) : iSize( aSize )
+ {
+ for( TInt i=0; i<KAknsRlDefaultRendererLayerN; i++ )
+ {
+ iLayers[i].iRGBBitmap = NULL;
+ iLayers[i].iRGBDevice = NULL;
+ iLayers[i].iRGBGc = NULL;
+ iLayers[i].iAlphaBitmap = NULL;
+ iLayers[i].iAlphaDevice = NULL;
+ iLayers[i].iAlphaGc = NULL;
+ }
+ iSkinSrvSession = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultEffectContext::~CAknsRlDefaultEffectContext
+// -----------------------------------------------------------------------------
+//
+CAknsRlDefaultEffectContext::~CAknsRlDefaultEffectContext()
+ {
+ for( TInt i=0; i<KAknsRlDefaultRendererLayerN; i++ )
+ {
+ delete iLayers[i].iRGBBitmap;
+ delete iLayers[i].iRGBDevice;
+ delete iLayers[i].iRGBGc;
+ delete iLayers[i].iAlphaBitmap;
+ delete iLayers[i].iAlphaDevice;
+ delete iLayers[i].iAlphaGc;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultEffectContext::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CAknsRlDefaultEffectContext::ConstructL()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultEffectContext::LayerSize
+// -----------------------------------------------------------------------------
+//
+const TSize CAknsRlDefaultEffectContext::LayerSize()
+ {
+ return iSize;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultEffectContext::GetLayerDataL
+// -----------------------------------------------------------------------------
+//
+void CAknsRlDefaultEffectContext::GetLayerDataL( TAknsRlLayerData& aData,
+ const TInt aLayerIndex, const TInt aLayerStatus,
+ const TBool aInitialize )
+ {
+ if( (aLayerIndex<0) || (aLayerIndex>=KAknsRlDefaultRendererLayerN) )
+ {
+ User::Leave( KAknsRlErrBadLayerIndex );
+ }
+
+ CreateIfNeededL( aLayerIndex, aLayerStatus, aInitialize );
+
+ if( (aLayerStatus==KAknsRlLayerRGBOnly) ||
+ (aLayerStatus==KAknsRlLayerRGBA) )
+ {
+ aData.iRGBBitmap = iLayers[aLayerIndex].iRGBBitmap;
+ aData.iRGBDevice = iLayers[aLayerIndex].iRGBDevice;
+ aData.iRGBGc = iLayers[aLayerIndex].iRGBGc;
+ }
+ if( (aLayerStatus==KAknsRlLayerAlphaOnly) ||
+ (aLayerStatus==KAknsRlLayerRGBA) )
+ {
+ aData.iAlphaBitmap = iLayers[aLayerIndex].iAlphaBitmap;
+ aData.iAlphaDevice = iLayers[aLayerIndex].iAlphaDevice;
+ aData.iAlphaGc = iLayers[aLayerIndex].iAlphaGc;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultEffectContext::DetachLayerBitmaps
+// -----------------------------------------------------------------------------
+//
+void CAknsRlDefaultEffectContext::DetachLayerBitmaps( const TInt aLayerIndex )
+ {
+ iLayers[aLayerIndex].iRGBBitmap = NULL;
+ iLayers[aLayerIndex].iAlphaBitmap = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultEffectContext::CreateIfNeededL
+// -----------------------------------------------------------------------------
+//
+void CAknsRlDefaultEffectContext::CreateIfNeededL( const TInt aLayerIndex,
+ const TInt aLayerStatus, const TBool aInitialize )
+ {
+ if( iLayers[aLayerIndex].iRGBBitmap &&
+ iLayers[aLayerIndex].iAlphaBitmap ) return;
+
+ if( iLayers[aLayerIndex].iRGBBitmap ||
+ iLayers[aLayerIndex].iAlphaBitmap )
+ User::Leave( KAknsRlErrInternalState );
+
+ TSize size = LayerSize();
+
+ CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL( bitmap );
+ User::LeaveIfError(
+ bitmap->Create( size, DefaultRenderingMode() ) );
+
+ CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL( bitmap );
+ CleanupStack::PushL( dev );
+
+ CFbsBitGc* gc = CFbsBitGc::NewL();
+ CleanupStack::PushL( gc );
+ gc->Activate( dev );
+
+ iLayers[aLayerIndex].iRGBBitmap = bitmap;
+ iLayers[aLayerIndex].iRGBDevice = dev;
+ iLayers[aLayerIndex].iRGBGc = gc;
+ CleanupStack::Pop(3); // gc, dev, bitmap
+
+ bitmap = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL( bitmap );
+ AknIconConfig::TPreferredDisplayMode mode;
+ AknIconConfig::PreferredDisplayMode(mode, AknIconConfig::EImageTypeOffscreen);
+
+ User::LeaveIfError(
+ bitmap->Create( size, mode.iMaskMode ) );
+
+ dev = CFbsBitmapDevice::NewL( bitmap );
+ CleanupStack::PushL( dev );
+
+ gc = CFbsBitGc::NewL();
+ CleanupStack::PushL( gc );
+ gc->Activate( dev );
+
+ iLayers[aLayerIndex].iAlphaBitmap = bitmap;
+ iLayers[aLayerIndex].iAlphaDevice = dev;
+ iLayers[aLayerIndex].iAlphaGc = gc;
+ CleanupStack::Pop(3); // gc, dev, bitmap
+
+ if( aInitialize )
+ {
+ switch( aLayerStatus )
+ {
+ case KAknsRlLayerRGBOnly:
+ iLayers[aLayerIndex].iRGBGc->SetBrushColor( KRgbBlack );
+ iLayers[aLayerIndex].iRGBGc->Clear();
+ iLayers[aLayerIndex].iAlphaGc->SetBrushColor( KRgbWhite );
+ iLayers[aLayerIndex].iAlphaGc->Clear();
+ break;
+ default:
+ iLayers[aLayerIndex].iRGBGc->SetBrushColor( KRgbBlack );
+ iLayers[aLayerIndex].iRGBGc->Clear();
+ iLayers[aLayerIndex].iAlphaGc->SetBrushColor( KRgbBlack );
+ iLayers[aLayerIndex].iAlphaGc->Clear();
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultEffectContext::GetSkinSrvSession
+// -----------------------------------------------------------------------------
+//
+RAknsSrvSession* CAknsRlDefaultEffectContext::GetSkinSrvSession()
+ {
+ return iSkinSrvSession;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsRlDefaultEffectContext::SetSkinSrvSession
+// -----------------------------------------------------------------------------
+//
+void CAknsRlDefaultEffectContext::SetSkinSrvSession(RAknsSrvSession* aSession)
+ {
+ iSkinSrvSession = aSession;
+ }
+
+// End of File