/*

* 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:  Context for frames.

*

*/

// INCLUDE FILES

#include "AknsCppPreface.h"

#include <AknsFrameBackgroundControlContext.h>

#include <AknsItemData.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include "AknsBackgroundLayout.h"

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

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

// CAknsFrameBackgroundControlContext::CAknsFrameBackgroundControlContext

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

// might leave.

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

//

CAknsFrameBackgroundControlContext::CAknsFrameBackgroundControlContext() :

    CAknsLayeredBackgroundControlContext(),

    iInnerRect(0,0,1,1), iOuterRect(0,0,1,1), iSingleElementFrame( EFalse )

    {

    iFrameID = KAknsIIDNone;

    iCenterID = KAknsIIDDefault;

    }

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

// CAknsFrameBackgroundControlContext::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknsFrameBackgroundControlContext::ConstructL(

    const TAknsItemID& aFrameID, const TRect& aOuterRect,

    const TRect& aInnerRect, const TBool aParentAbsolute )

    {

    CAknsLayeredBackgroundControlContext::ConstructL( TRect(0,0,1,1),

        aParentAbsolute, KAknsIIDNone, EAknsFrameElementsN );

    SetFrameRects( aOuterRect, aInnerRect );

    SetFrame( aFrameID );

    }

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

// CAknsFrameBackgroundControlContext::NewL

// Two-phased constructor.

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

//

AKNS_EXPORTED_METHOD(CAknsFrameBackgroundControlContext::NewL)

EXPORT_C CAknsFrameBackgroundControlContext*

    CAknsFrameBackgroundControlContext::NewL(

    const TAknsItemID& aFrameID, const TRect& aOuterRect,

    const TRect& aInnerRect, const TBool aParentAbsolute )

    {

    CAknsFrameBackgroundControlContext* self =

        new( ELeave ) CAknsFrameBackgroundControlContext();

    CleanupStack::PushL( self );

    self->ConstructL( aFrameID, aOuterRect, aInnerRect, aParentAbsolute );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknsFrameBackgroundControlContext::~CAknsFrameBackgroundControlContext

// Destructor.

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

//

CAknsFrameBackgroundControlContext::~CAknsFrameBackgroundControlContext()

    {

    }

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

// CAknsFrameBackgroundControlContext::SetFrame

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

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

//

EXPORT_C void CAknsFrameBackgroundControlContext::SetFrame(

    const TAknsItemID& aFrameID )

    {

    iFrameID = aFrameID;

    iCenterID = KAknsIIDDefault;

    TInt i;

    for( i=0; i<EAknsFrameElementsN; i++ )

        {

        SetLayerImage( i, KAknsIIDNone );

        }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if( !skin )

        {

        return;

        }

    CAknsImageItemData* imgData = static_cast<CAknsImageItemData*>(

        skin->GetCachedItemData( aFrameID, EAknsITImage ) );

    if( !imgData )

        {

        return;

        }

    //lint --e{961} Valid logic

    if( AknsUtils::IsDerivedType( EAknsITBitmap, imgData->Type() ) )

        {

        iSingleElementFrame = ETrue;

        SetLayerImage( 0, aFrameID );

        }

    else if( AknsUtils::IsDerivedType( EAknsITImageTable, imgData->Type() ) )

        {

        iSingleElementFrame = EFalse;

        CAknsImageTableItemData* itData =

            static_cast<CAknsImageTableItemData*>(imgData);

        if( itData->NumberOfImages()!=9 )

            {

            return;

            }

        SetLayerImage( 0, itData->ImageIID( EAknsFrameIndexCenter ) );

        for( i=0; i<EAknsFrameElementsN-1; i++ )

            {

            SetLayerImage( i+1, itData->ImageIID( i ) );

            }

        }

    // Since we can not leave, just tolerate the unsupported type

    UpdateFrame();

    }

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

// CAknsFrameBackgroundControlContext::SetFrameRects

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

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

//

EXPORT_C void CAknsFrameBackgroundControlContext::SetFrameRects(

    const TRect& aOuterRect,

    const TRect& aInnerRect )

    {

    iOuterRect = aOuterRect;

    iInnerRect = aInnerRect;

    // Center

    // Center layer rectangle handled by UpdateFrame

    // Corners

    SetLayerRect( EAknsFrameIndexTl+1,

        TRect( aOuterRect.iTl, aInnerRect.iTl ) );

    SetLayerRect( EAknsFrameIndexTr+1,

        TRect( aInnerRect.iBr.iX, aOuterRect.iTl.iY,

        aOuterRect.iBr.iX, aInnerRect.iTl.iY ) );

    SetLayerRect( EAknsFrameIndexBl+1,

        TRect( aOuterRect.iTl.iX, aInnerRect.iBr.iY,

        aInnerRect.iTl.iX, aOuterRect.iBr.iY ) );

    SetLayerRect( EAknsFrameIndexBr+1,

        TRect( aInnerRect.iBr, aOuterRect.iBr ) );

    // Sides

    TRect sideRect( aInnerRect.iTl.iX, aOuterRect.iTl.iY,

        aInnerRect.iBr.iX, aInnerRect.iTl.iY );

    SetLayerRect( EAknsFrameIndexT+1, sideRect );

    sideRect.SetRect( aInnerRect.iTl.iX, aInnerRect.iBr.iY,

        aInnerRect.iBr.iX, aOuterRect.iBr.iY );

    SetLayerRect( EAknsFrameIndexB+1, sideRect );

    sideRect.SetRect( aOuterRect.iTl.iX, aInnerRect.iTl.iY,

        aInnerRect.iTl.iX, aInnerRect.iBr.iY );

    SetLayerRect( EAknsFrameIndexL+1, sideRect );

    sideRect.SetRect( aInnerRect.iBr.iX, aInnerRect.iTl.iY,

        aOuterRect.iBr.iX, aInnerRect.iBr.iY );

    SetLayerRect( EAknsFrameIndexR+1, sideRect );

    UpdateFrame();

    }

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

// CAknsFrameBackgroundControlContext::SetCenter

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

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

//

AKNS_EXPORTED_METHOD(CAknsFrameBackgroundControlContext::SetCenter)

EXPORT_C void CAknsFrameBackgroundControlContext::SetCenter(

    const TAknsItemID& aID )

    {

    iCenterID = aID;

    iLayout->iImageID = aID;

    }

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

// CAknsFrameBackgroundControlContext::SetFramePartRect

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

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

//

AKNS_EXPORTED_METHOD(CAknsFrameBackgroundControlContext::SetFramePartRect)

EXPORT_C void CAknsFrameBackgroundControlContext::SetFramePartRect(

    const TRect& aRect,

    const TAknsFrameElementIndex aFrameElement )

    {

    if( aFrameElement == EAknsFrameIndexCenter )

        {

        iInnerRect = aRect;

        // Center layer rectangle handled by UpdateFrame

        }

    else

        {

        //lint --e{961} Valid logic

        if( aFrameElement == EAknsFrameIndexTl )

            {

            iOuterRect.iTl = aRect.iTl;

            }

        else if( aFrameElement == EAknsFrameIndexBr )

            {

            iOuterRect.iBr = aRect.iBr;

            }

        // None of the other cases change outer rect

        SetLayerRect( aFrameElement+1 , aRect );

        }

    UpdateFrame();

    }

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

// CAknsFrameBackgroundControlContext::IsCompatibleWithType

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

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

//

TBool CAknsFrameBackgroundControlContext::IsCompatibleWithType(

    const TAknsControlContextType aType ) const

    {

    switch( aType )

        {

        case EAknsControlContextTypeUnknown:

        case EAknsControlContextTypeBasic:

        case EAknsControlContextTypeLayered:

        case EAknsControlContextTypeFrame:

            return ETrue;

        case EAknsControlContextTypeListBox:

            break;

        }

    return EFalse;

    }

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

// CAknsFrameBackgroundControlContext::UpdateContext

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

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

//

TInt CAknsFrameBackgroundControlContext::UpdateContext()

    {

    SetFrame( iFrameID );

    if( (!iSingleElementFrame) && (iCenterID!=KAknsIIDDefault) )

        {

        SetCenter( iCenterID );

        }

    return 0;

    }

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

// CAknsFrameBackgroundControlContext::UpdateFrame

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

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

//

void CAknsFrameBackgroundControlContext::UpdateFrame()

    {

    if( iSingleElementFrame )

        {

        iLayout->iNext = NULL;

        SetLayerRect( 0, iOuterRect );

        }

    else

        {

        iLayout->iNext = &(iLayoutArray[0]);

        SetLayerRect( 0, iInnerRect );

        }

    MAknsSkinInstance* skininstance = AknsUtils::SkinInstance();

    AknsDrawUtils::PrepareFrame( skininstance,

        iOuterRect, iInnerRect,

        iFrameID, iCenterID);

    }

//  End of File