/*

* 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:  Class for providing effect context for effect plugins.

*

*/

// INCLUDE FILES

#include "AknsRlErr.h"

#include "AknsAlEffectContext.h"

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::CAknsAlEffectContext

// -----------------------------------------------------------------------------

//

CAknsAlEffectContext::CAknsAlEffectContext()

    {

    // Derived from CBase -> all data is zeroed

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::NewL

// -----------------------------------------------------------------------------

//

CAknsAlEffectContext* CAknsAlEffectContext::NewL()

    {

    CAknsAlEffectContext* self = new(ELeave) CAknsAlEffectContext();

    return self;

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::~CAknsAlEffectContext

// -----------------------------------------------------------------------------

//

CAknsAlEffectContext::~CAknsAlEffectContext()

    {

    ReleaseLayers(); //lint !e1551 No exception thrown

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::ConfigureL

// -----------------------------------------------------------------------------

//

void CAknsAlEffectContext::ConfigureL( const TSize& aSize,

                                       TDisplayMode aRgbMode,

                                       TInt aInputLayerIndex,

                                       TInt aInputLayerMode )

    {

    iLayerSize = aSize;

    iRgbMode = aRgbMode;

    ReleaseLayers();

    if( aInputLayerIndex < 0 ) // Input layer is set to none

        {

        return;

        }

    CreateIfNeededL( aInputLayerIndex, aInputLayerMode, ETrue );

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::RgbBitmap

// -----------------------------------------------------------------------------

//

CFbsBitmap* CAknsAlEffectContext::RgbBitmap( TInt aLayerIndex ) const

    {

    if( aLayerIndex < 0 || aLayerIndex >= KAknsAlEffectContextLayerN )

        return NULL;

    return iLayers[aLayerIndex].iRGBBitmap;

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::AlphaBitmap

// -----------------------------------------------------------------------------

//

CFbsBitmap* CAknsAlEffectContext::AlphaBitmap( TInt aLayerIndex ) const

    {

    if( aLayerIndex < 0 || aLayerIndex >= KAknsAlEffectContextLayerN )

        return NULL;

    return iLayers[aLayerIndex].iAlphaBitmap;

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::RgbGc

// -----------------------------------------------------------------------------

//

CFbsBitGc* CAknsAlEffectContext::RgbGc( TInt aIndex ) const

    {

    if( aIndex < 0 || aIndex >= KAknsAlEffectContextLayerN )

        return NULL;

    return iLayers[aIndex].iRGBGc;

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::AlphaGc

// -----------------------------------------------------------------------------

//

CFbsBitGc* CAknsAlEffectContext::AlphaGc( TInt aIndex ) const

    {

    if( aIndex < 0 || aIndex >= KAknsAlEffectContextLayerN )

        return NULL;

    return iLayers[aIndex].iAlphaGc;

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::ReleaseInputLayers

// -----------------------------------------------------------------------------

//

void CAknsAlEffectContext::ReleaseInputLayers( TInt aOutputLayerIndex )

    {

    // It is possible that output layer is also one of the input layers ->

    // delete all layers that are not output layer.

    for( int i=0; i < KAknsAlEffectContextLayerN; i++ )

        {

        if( i != aOutputLayerIndex )

            {

            ReleaseLayer( i );

            }

        }

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::SetSkinSrvSession

// -----------------------------------------------------------------------------

//

void CAknsAlEffectContext::SetSkinSrvSession( RAknsSrvSession* aSession )

    {

    iSession = aSession;

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::LayerSize

// -----------------------------------------------------------------------------

//

const TSize CAknsAlEffectContext::LayerSize()

    {

    return iLayerSize;

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::GetLayerDataL

// -----------------------------------------------------------------------------

//

void CAknsAlEffectContext::GetLayerDataL( TAknsRlLayerData& aData,

                                          const TInt aLayerIndex,

                                          const TInt aLayerStatus,

                                          const TBool aInitialize )

    {

    if( ( aLayerIndex < 0 ) || ( aLayerIndex >= KAknsAlEffectContextLayerN ) )

        {

        User::Leave( KAknsRlErrBadLayerIndex );

        }

    CreateIfNeededL( aLayerIndex, aLayerStatus, aInitialize );

    /*lint -save -e661 */ // Index is boundary checked above

    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;

        }

    /*lint -restore */

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::GetSkinSrvSession

// -----------------------------------------------------------------------------

//

RAknsSrvSession* CAknsAlEffectContext::GetSkinSrvSession()

    {

    return iSession;

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::CreateIfNeededL

// -----------------------------------------------------------------------------

//

void CAknsAlEffectContext::CreateIfNeededL( const TInt aLayerIndex,

    const TInt aLayerStatus, const TBool aInitialize )

    {

    if( ( aLayerIndex < 0 ) || ( aLayerIndex >= KAknsAlEffectContextLayerN ) )

        {

        User::Leave( KAknsRlErrBadLayerIndex );

        }

    /*lint -save -e661 */ // Index is boundary checked above

    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, iRgbMode ) );

    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 );

    User::LeaveIfError( bitmap->Create( size, EGray256 ) );

    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;

            }

        }

    /*lint -restore */

    }//lint !e661 Layer index is boundary checked

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::ReleaseLayers

// -----------------------------------------------------------------------------

//

void CAknsAlEffectContext::ReleaseLayers()

    {

    for( TInt i=0; i < KAknsAlEffectContextLayerN; i++ )

        {

        ReleaseLayer( i );

        }

    }

// -----------------------------------------------------------------------------

// CAknsAlEffectContext::ReleaseLayer

// -----------------------------------------------------------------------------

//

void CAknsAlEffectContext::ReleaseLayer( const TInt aLayerIndex )

    {

    ASSERT( aLayerIndex >= 0 && aLayerIndex < KAknsAlEffectContextLayerN );

    /*lint -save -e661 */ // Never called with invalid index

    delete iLayers[aLayerIndex].iRGBBitmap;

    delete iLayers[aLayerIndex].iRGBDevice;

    delete iLayers[aLayerIndex].iRGBGc;

    delete iLayers[aLayerIndex].iAlphaBitmap;

    delete iLayers[aLayerIndex].iAlphaDevice;

    delete iLayers[aLayerIndex].iAlphaGc;

    iLayers[aLayerIndex].iRGBBitmap   = NULL;

    iLayers[aLayerIndex].iRGBDevice   = NULL;

    iLayers[aLayerIndex].iRGBGc       = NULL;

    iLayers[aLayerIndex].iAlphaBitmap = NULL;

    iLayers[aLayerIndex].iAlphaDevice = NULL;

    iLayers[aLayerIndex].iAlphaGc     = NULL;

    /*lint -restore */

    }

// End of File