/*

* Copyright (c) 2007-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:  Layered background control context with mask bitmap.

*

*/

#include "AknsCppPreface.h"

#include "AknsMaskedLayerBackgroundControlContext.h"

#include <AknsUtils.h>

#include "AknsBackgroundLayout.h"

#include "AknsDebug.h"

#include "AknIconUtils.h"

#include <AknsDrawUtils.h>

#include "AknsAppSkinInstance.h"

// ======== MEMBER FUNCTIONS ========

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

// CAknsMaskedLayerBackgroundControlContext::CAknsMaskedLayerBackgroundControlContext

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAknsMaskedLayerBackgroundControlContext::CAknsMaskedLayerBackgroundControlContext() :

    CAknsLayeredBackgroundControlContext()

    // CBase initializes: iLayoutArray(NULL), iLayoutArraySize(0)

    {

    }

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

// CAknsMaskedLayerBackgroundControlContext::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknsMaskedLayerBackgroundControlContext::ConstructL(

    const TRect& aRect, const TBool aParentAbsolute,

    const TAknsItemID& aImageID, const TInt aNumberOfLayers  )

    {

    CAknsLayeredBackgroundControlContext::ConstructL( aRect, aParentAbsolute,

        aImageID, aNumberOfLayers );

    }

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

// CAknsMaskedLayerBackgroundControlContext::NewL

// Two-phased constructor.

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

//

AKNS_EXPORTED_METHOD(CAknsMaskedLayerBackgroundControlContext::NewL)

EXPORT_C CAknsMaskedLayerBackgroundControlContext*

    CAknsMaskedLayerBackgroundControlContext::NewL(

    const TAknsItemID& aImageID, const TRect& aRect,

    const TBool aParentAbsolute, const TInt aNumberOfLayers  )

    {

#ifndef RD_FULLSCREEN_WALLPAPER

    User::Leave( KErrNotSupported );

#endif //RD_FULLSCREEN_WALLPAPER

    CAknsMaskedLayerBackgroundControlContext* self =

        new( ELeave ) CAknsMaskedLayerBackgroundControlContext();

    CleanupStack::PushL( self );

    self->ConstructL( aRect, aParentAbsolute, aImageID, aNumberOfLayers );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CAknsMaskedLayerBackgroundControlContext::~CAknsMaskedLayerBackgroundControlContext()

    {

#ifndef RD_FULLSCREEN_WALLPAPER

    return;

#else

    delete iOffScreenDevice;

    delete iOffScreenGc;

    delete iOffScreenBmp;

    delete iLayerMask;

#endif //RD_FULLSCREEN_WALLPAPER

    }

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

// CAknsMaskedLayerBackgroundControlContext::SetLayerImage

// (other items were commented in a header).

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

//

AKNS_EXPORTED_METHOD(CAknsMaskedLayerBackgroundControlContext::SetLayerImage)

EXPORT_C void CAknsMaskedLayerBackgroundControlContext::SetLayerImage(

    const TInt aLayer, const TAknsItemID& aID )

    {

#ifndef RD_FULLSCREEN_WALLPAPER

    return;

#else

    CAknsLayeredBackgroundControlContext::SetLayerImage(

        aLayer,

        aID );

#endif //RD_FULLSCREEN_WALLPAPER

    }

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

// CAknsMaskedLayerBackgroundControlContext::SetLayerRect

// (other items were commented in a header).

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

//

AKNS_EXPORTED_METHOD(CAknsMaskedLayerBackgroundControlContext::SetLayerRect)

EXPORT_C void CAknsMaskedLayerBackgroundControlContext::SetLayerRect(

    const TInt aLayer, const TRect& aRect )

    {

#ifndef RD_FULLSCREEN_WALLPAPER

    return;

#else

    CAknsLayeredBackgroundControlContext::SetLayerRect(

        aLayer,

        aRect );

#endif //RD_FULLSCREEN_WALLPAPER

    }

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

// CAknsMaskedLayerBackgroundControlContext::SetLayerMaskAndSizeL

// (other items were commented in a header).

// By default layer depth is set to one.

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

//

AKNS_EXPORTED_METHOD(CAknsMaskedLayerBackgroundControlContext::SetLayerMaskAndSizeL)

EXPORT_C void CAknsMaskedLayerBackgroundControlContext::SetLayerMaskAndSizeL(

    const TAknsItemID& aIID, const TRect& aMaskRect )

    {

#ifndef RD_FULLSCREEN_WALLPAPER

    User::Leave( KErrNotSupported );

    return;

#else

    if ( iOffScreenDevice )

        {

        delete iOffScreenDevice;

        iOffScreenDevice = NULL;

        }

    if ( iOffScreenGc )

        {

        delete iOffScreenGc;

        iOffScreenGc = NULL;

        }

    if ( iLayerMask )

        {

        delete iLayerMask;

        iLayerMask = NULL;

        }

    if ( iOffScreenBmp )

        {

        delete iOffScreenBmp;

        iOffScreenBmp = NULL;

        }

    // Client did not set mask - previous mask & offscreen bitmap

    // deleted, just return.

    if ( aIID == KAknsIIDNone )

        {

        return;

        }

    // Only do this if layer 0 is actually available.

    CAknsItemData* itemData = NULL;

    MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

    if ( skinInstance )

        {        

        TRAP_IGNORE(

            itemData = skinInstance->CreateUncachedItemDataL(

                iLayout->iImageID, EAknsITUnknown ) );

        }

    if ( itemData )

        {

        // Create layer mask item.

        AknsUtils::CreateIconL(AknsUtils::SkinInstance(), aIID, iLayerMask, KNullDesC, 0);

        User::LeaveIfError(AknIconUtils::SetSize(iLayerMask, aMaskRect.Size(),EAspectRatioNotPreserved));

        // Create offscreen bitmap.

        iOffScreenBmp = new (ELeave) CFbsBitmap;

        CAknsAppSkinInstance* appInstance = 

                static_cast<CAknsAppSkinInstance*>(skinInstance); 

        if ( appInstance && appInstance->AnimBackgroundState() )

            iOffScreenBmp->Create(aMaskRect.Size(), EColor16MA);

        else

            iOffScreenBmp->Create(aMaskRect.Size(), EColor64K);

        iOffScreenDevice = CFbsBitmapDevice::NewL(iOffScreenBmp);

        User::LeaveIfError(iOffScreenDevice->CreateContext(iOffScreenGc));

        TPoint myPoint( 0, 0 );

        // Draw the upper layers to offscreen bitmap.

        AknsDrawUtils::DrawBackground(

            AknsUtils::SkinInstance(),

            this,

            NULL,

            *iOffScreenGc,

            myPoint,

            aMaskRect,

            KAknsDrawParamIgnoreLayerMask );

        }

    if (itemData)

        {

        delete itemData;

        }

#endif //RD_FULLSCREEN_WALLPAPER

    }

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

// CAknsMaskedLayerBackgroundControlContext::IsCompatibleWithType

// (other items were commented in a header).

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

//

TBool CAknsMaskedLayerBackgroundControlContext::IsCompatibleWithType(

    const TAknsControlContextType aType ) const

    {

#ifndef RD_FULLSCREEN_WALLPAPER

    return EFalse;

#else

    if ( aType == EAknsControlContextTypeMasked )

        {

        return ETrue;

        }

    return EFalse;

#endif //RD_FULLSCREEN_WALLPAPER

    }

// End of file