/*

* 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