/*

* 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:  Drawing utility class.

*

*/

// INCLUDE FILES

#include "AknsCppPreface.h"

#include <coecntrl.h>

#include <w32std.h>

#include <AknStatuspaneUtils.h>

#include "layoutmetadata.cdl.h"

#include "AknsDrawUtils.h"

#include "AknsItemData.h"

#include <AknsSkinInstance.h>

#include <AknsControlContext.h>

#include "AknsBackgroundLayout.h"

#include <AknsImageAttributeData.h>

#include "AknsAppSkinInstance.h"

#include "AknsTemporaryBitmap.h"

#include "AknsScalabilityUtils.h"

#include <AknsLayeredBackgroundControlContext.h>

#include "AknsMaskedLayerBackgroundControlContext.h"

#include "AknsRlMasterLayout.h"

#include "AknsRlUtils.h"

#include "AknSkinsVariant.hrh"

#include "AknsDebug.h"

#ifdef RD_SLIDING_ANIMATION_EFFECTS

_LIT(KAknsDrawUtilsSLDisabled,"ds");

_LIT(KAknsDrawUtilsSLFromCBA ,"cba");

_LIT(KAknsDrawUtilsSLFromL,   "l");

_LIT(KAknsDrawUtilsSLFromTL,  "tl");

_LIT(KAknsDrawUtilsSLFromT,   "t");

_LIT(KAknsDrawUtilsSLFromTR,  "tr");

_LIT(KAknsDrawUtilsSLFromR,   "r");

_LIT(KAknsDrawUtilsSLFromBR,  "br");

_LIT(KAknsDrawUtilsSLFromB,   "b");

_LIT(KAknsDrawUtilsSLFromBl,  "bl");

_LIT(KAknsDrawUtilsSLRnd,     "rnd");

#endif

AKNS_UNDEFINED_METHOD(AknsDrawUtils::AknsDrawUtils)

// ============================= LOCAL FUNCTIONS ===============================

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

// IsSinglePart

//

// Checks whether the given item is a single-part image (bitmap or masked bitmap)

//

// Returns: ETrue or EFalse

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

//

static TBool IsSinglePart(

    MAknsSkinInstance* aInstance, const TAknsItemID& aIID )

    {

    CAknsItemData* fdata = aInstance->GetCachedItemData(

        aIID, EAknsITBitmap );

    if( fdata )

        {

        if( fdata->Type()==EAknsITBitmap

            || fdata->Type()==EAknsITMaskedBitmap )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// RetrieveKnownBackgroundImage

//

// Retrieves background image item data that has a known item ID (if any)

//

// Returns: Pointer to cached background image, or NULL

//          if none found.

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

//

static CAknsImageItemData* RetrieveKnownBackgroundImage(

    MAknsSkinInstance* aInstance,

    const TAknsItemID& aIID, const TAknsBackground* aLayout = NULL )

    {

    if( !aInstance || aIID == KAknsIIDDefault || aIID == KAknsIIDNone )

        {

        return NULL;

        }

    TAknsItemID id = aIID;

    // special handling for main panes

    if (aIID == KAknsIIDQsnBgAreaMain ||

        aIID == KAknsIIDQsnBgAreaMainListGene ||

        aIID == KAknsIIDQsnBgAreaMainListSet ||

        aIID == KAknsIIDQsnBgAreaMainMessage)

        {

        if (AknStatuspaneUtils::FlatLayoutActive())

            {

            id = KAknsIIDQsnBgAreaMainFlat;

            }

        else if (AknStatuspaneUtils::SmallLayoutActive())

            {

            id = KAknsIIDQsnBgAreaMainSmall;

            }

        }

    // Special handling for popup centerpieces

    if( AknsRlUtils::IsPopupCenter( id )

        && IsSinglePart( aInstance, KAknsIIDQsnFrPopup ) )

        {

        // Frame exists and is not image table, return surrounding frame

        return static_cast<CAknsImageItemData*>(

            aInstance->GetCachedItemData( KAknsIIDQsnFrPopup, EAknsITImage ) );

        }

    CAknsItemData* idata = aInstance->GetCachedItemData( id ); //lint !e613 Always non-null

    if( idata && AknsUtils::IsDerivedType( EAknsITImage, idata->Type()) )

        {

        return static_cast<CAknsImageItemData*>(idata);

        }

    // Render only if...

    TBool doScalableRendering( EFalse );

    CAknsAppSkinInstance* appSkinInstance =

        static_cast<CAknsAppSkinInstance*>(aInstance);

    if( idata )

        {

        if( AknsUtils::IsDerivedType( EAknsITEffectQueue, idata->Type() ) )

            {

            // ... 1) data exists and is an effect queue or...

            doScalableRendering = ETrue;

            }

        else if( AknsUtils::IsDerivedType( EAknsITAnimation, idata->Type() ) )

            {

            CAknsAnimationItemData* adata =

                static_cast<CAknsAnimationItemData*>( idata );

            if( adata->Morphing() )

                {

                // ... 2) data exists and is a morphing animation element...

                doScalableRendering = ETrue;

                }

            }

        }

    else 

        {

            if( (appSkinInstance->MasterLayout()->GetParent(id) != KAknsIIDDefault) )

            {

            // ...or data does not exist and there is a (definite, but possibly

            // non-existing) parent.

            doScalableRendering = ETrue;

            }

        }

    if( doScalableRendering )

        {

        return AknsScalabilityUtils::ConvertToBitmap(appSkinInstance, id, aLayout);

        }

    return NULL;

    }

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

// RetrieveBackgroundImage

//

// Retrieves background image item data (if any)

//

// Returns: Pointer to cached background image, or NULL

//          if none found.

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

//

static CAknsImageItemData* RetrieveBackgroundImage(

    MAknsSkinInstance* aInstance,

    const TAknsBackground* aLayout, TAknsItemID& aIID )

    {

    aIID = aLayout ? aLayout->iImageID : KAknsIIDNone;

    return RetrieveKnownBackgroundImage( aInstance, aIID, aLayout );

    }

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

// RetrieveBackgroundLayout

//

// Retrieves pointer (not owned) to background layout.

//

// Returns: Pointer to background layout, or NULL

//          if none found.

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

//

static TAknsBackground* RetrieveBackgroundLayout(

    MAknsControlContext* aContext )

    {

    if( aContext )

        {

        return static_cast<TAknsBackground*>(

            aContext->SupplySkinObject( EAknsCCOBackground ) );

        }

    return NULL;

    }

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

// GetParentAbsoluteDelta

//

// Calculates position delta based on parent absolute layout.

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

//

static TPoint GetParentAbsoluteDelta(

    const TAknsBackground* aLayout,

    const CCoeControl* aControl )

    {

    TPoint p(0,0);

    if( aLayout && aLayout->iParentAbsolute && aControl )

        {

        TPoint cachedPos;

        if( AknsUtils::GetControlPosition( aControl, cachedPos ) == KErrNone )

            {

            p = cachedPos;

            }

        else

            {

            __ASSERT_DEBUG( aControl->DrawableWindow(),

                AKNS_DEBUG_PANIC(EAknsDPanicNoWindow) );

            // For release build, play it safe

            if( !aControl->DrawableWindow() )

                {

                return p;

                }

            p = aControl->PositionRelativeToScreen();

            }

        if( !aControl->OwnsWindow() )

            {

            p -= aControl->Position();

            }

        p -= aLayout->iParentPos;

        }

    return p;

    }

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

// DrawPartialCachedImage

//

// Draws the specified part of an image with layout.

//

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

//

    MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgLayoutRect,

    const TRect& aTrgDrawRect, CAknsImageItemData* aImgData,

    const TAknsItemID& aIID, const TAknsImageAttributeData* aAttr,

    const TInt aDrawParam )

    {

    TRect trgLayoutRect( aTrgLayoutRect );

    // Adjust "faked" centerpiece region

    if( AknsRlUtils::IsPopupCenter(aIID)

        && IsSinglePart( aSkin, KAknsIIDQsnFrPopup ) )

        {

        TSize tl, br;

        AknsRlUtils::GetPopupFrameDimensions( tl, br );

        trgLayoutRect.iTl -= tl;

        trgLayoutRect.iBr += br;

        }

        aTrgDrawRect, aImgData, aIID, aAttr, aDrawParam );

    }

static TBool IsBackgroundItem( const TAknsItemID& aIID,CAknsAppSkinInstance* aSkin )

    {

    TBool isbg = EFalse;

    if( aIID.iMajor == EAknsMajorSkin)

        {

        switch (aIID.iMinor)

            {

            case EAknsMinorQsnBgScreen:

            case EAknsMinorQsnBgScreenIdle:

            case EAknsMinorQsnBgScreenMp:

            case EAknsMinorQsnBgAreaMain:

            case EAknsMinorQsnBgAreaMainAppsGrid:

            case EAknsMinorQsnBgAreaMainListGene:

            case EAknsMinorQsnBgAreaMainListSet:

            case EAknsMinorQsnBgAreaMainMessage:

            case EAknsMinorQsnBgAreaMainHigh:

            case EAknsMinorQsnBgAreaMainCalc:

            case EAknsMinorQsnBgAreaMainPinb:

            case EAknsMinorQsnBgAreaMainQdial:

            case EAknsMinorQsnBgAreaMainMp:

            case EAknsMinorQsnBgAreaMainFlat:

            case EAknsMinorQsnBgAreaMainSmall:

            case EAknsMinorQsnBgAreaMainIdle:

            case EAknsMinorQsnBgAreaMainIdleDimmed:

            case EAknsMinorQsnBgAreaStatus:

            case EAknsMinorQsnBgAreaStatusIdle:

            case EAknsMinorQsnBgAreaStaconRt:

            case EAknsMinorQsnBgAreaStaconLt:

            case EAknsMinorQsnBgAreaStaconRb:

            case EAknsMinorQsnBgAreaStaconLb:

            case EAknsMinorQsnBgAreaStaconRtIdle:

            case EAknsMinorQsnBgAreaStaconLtIdle:

            case EAknsMinorQsnBgAreaStaconRbIdle:

            case EAknsMinorQsnBgAreaStaconLbIdle:

            case EAknsMinorQsnBgAreaControl:

            case EAknsMinorQsnBgAreaControlPopup:

            case EAknsMinorQsnBgAreaControlMp:

            case EAknsMinorQsnBgAreaControlIdle:

            case EAknsMinorQsnBgColumn0:

            case EAknsMinorQsnBgColumnA:

            case EAknsMinorQsnBgColumnAB:

            case EAknsMinorQsnBgColumnC0:

            case EAknsMinorQsnBgColumnCA:

            case EAknsMinorQsnBgColumnCAB:

            case EAknsMinorQsnBgSliceList0:

            case EAknsMinorQsnBgSliceListA:

            case EAknsMinorQsnBgSliceListAB:

                isbg = ETrue;

                break;

            case EAknsMinorWallpaper:

                {

                if ( aSkin && !aSkin->WallpaperDefined() )

                    {

                    isbg = ETrue;

                    }

                }

                break;

            default:

                break;

            }

        }

     else if (aIID.iMajor == EAknsMajorAvkon)

        {

        switch (aIID.iMinor)

            {

            case EAknsMinorQsnBgNavipaneSolid:

            case EAknsMinorQsnBgNavipaneWipe:

            case EAknsMinorQsnBgNavipaneSolidIdle:

            case EAknsMinorQsnBgNavipaneWipeIdle:

                isbg = ETrue;

            default:

                break;

            }

        }

    return isbg;

    }

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

// Blit

//

// Blits given image to gc.

//

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

//

    MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgRect,

    CAknsImageItemData* aImgData, const TAknsItemID& aIID,

    const TAknsBackground* aLayout, const TPoint& aPADelta,

    const TInt aDrawParam )

    {

    CAknsAppSkinInstance* appInstance = 

        static_cast<CAknsAppSkinInstance*>(aSkin);

    if ( IsBackgroundItem( aIID,appInstance ) && 

        {

        if( (aDrawParam&KAknsDrawParamPrepareOnly) )

            {

            return ETrue;

            }        

        TRgb color = KRgbWhite;

        color.SetAlpha(0x00);

        aGc.SetPenColor(color);

        aGc.SetBrushColor(color);

        aGc.SetPenStyle(CGraphicsContext::ESolidPen);

        aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

        aGc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

        TRect layoutRect( aTrgRect );

        if( aLayout )

            {

            layoutRect = aLayout->iRect;

            }

        layoutRect.Move( -aPADelta );

        TRect drawRect = aTrgRect;

        drawRect.Intersection( layoutRect );

        aGc.Clear(drawRect);

        return ETrue;

        }

    TRect layoutRect( aTrgRect );

    const TAknsImageAttributeData* attr = NULL;

    if( aLayout )

        {

        layoutRect = aLayout->iRect;

        if( aLayout->iAttr.iAttributes != EAknsImageAttributeNone )

            {

            attr = &(aLayout->iAttr);

            }

        }

    layoutRect.Move( -aPADelta );

    TRect drawRect(aTrgRect);

    drawRect.Intersection( layoutRect );

        aImgData, aIID, attr, aDrawParam );

    }

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

// BlitAndClear

//

// Blits given image to gc and draws the area that is not

// covered by the bitmap.

//

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

//

    MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgRect,

    CAknsImageItemData* aImgData, const TAknsItemID& aIID,

    const TAknsBackground* aLayout, const TPoint& aPADelta,

    const TInt aDrawParam )

    {

    CAknsAppSkinInstance* appInstance = 

            static_cast<CAknsAppSkinInstance*>(aSkin);

    if ( IsBackgroundItem( aIID,appInstance ) && 

            appInstance && appInstance->AnimBackgroundState() )

        {

        }

    if( !(aDrawParam & KAknsDrawParamPrepareOnly) )

        {

        TAknsItemType type = aImgData->Type();

        // don't clear if the item is not a masked one

        if( AknsUtils::IsDerivedType( EAknsITMaskedBitmap, type )  

                && !(aDrawParam & KAknsDrawParamNoClearUnderImage) )

            {

            TRect layoutRect( aTrgRect );

            if( aLayout )

                {

                layoutRect = aLayout->iRect;

                }

            layoutRect.Move( -aPADelta );

            TRect drawRect(aTrgRect);

            drawRect.Intersection( layoutRect );

            aGc.DrawRect( drawRect );

            }

        }

    }

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

//

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

//

    CBitmapContext& aGc, const TRect& aRect, const TAknsItemID& aIID,

    const TInt aDrawParam )

    {

    // Basic consistency checks

    if( !aSkin )

        {

        return EFalse;

        }

    CAknsItemData* data = aSkin->GetCachedItemData( aIID );

    if( !data )

        {

        return EFalse;

        }

    if( !AknsUtils::IsDerivedType( EAknsITImage, data->Type() ) )

        {

        return EFalse;

        }

        static_cast<CAknsImageItemData*>(data), aIID,

        NULL, aDrawParam );

    }

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

// GetParentContext

//

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

//

static MAknsControlContext* GetParentContext( MAknsControlContext* aContext )

    {

    if( aContext )

        {

        return static_cast<MAknsControlContext*>(

            aContext->SupplySkinObject( EAknsCCOParentContext ) );

        }