/*

* 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:  Internal utility class to handle scalability-related

                 operations.

*

*/

// INCLUDE FILES

#include "AknsCppPreface.h"

#include <coecntrl.h>

#include <w32std.h>

#include <AknIconUtils.h>

#include <akniconconfig.h>

#include "AknsScalabilityUtils.h"

#include <AknsDrawUtils.h>

#include <AknsItemData.h>

#include <AknsImageAttributeData.h>

#include "AknsTemporaryBitmap.h"

#include "AknsRlRenderer.h"

#include "AknsRlMasterLayout.h"

#include "AknsAppSkinInstance.h"

#include "AknsAlConversionUtil.h"

#include <AknsDrawUtils.h>

#include "AknSkinsVariant.hrh"

#include "AknsDebug.h"

#include "AknsBackgroundLayout.h"

// CONSTANTS

static const TInt KAknsSURErrNoParent   = -9000;

static const TInt KAknsSURErrNoLayout   = -9001;

static const TInt KAknsSURErrNoData     = -9002;

static const TInt KAknsSURecursionLimit = 8;

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

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

// GetSourceSize

//

// Retrieves source size based on the given size parameter and image data.

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

//

static TSize GetSourceSize(

    const TSize& aOverridingSize, const TSize& aTargetLayoutSize,

    CFbsBitmap* aBitmap, TBool& aPreserved )

    {

    // Use overriding size, if defined

    if( aOverridingSize.iWidth>=0 && aOverridingSize.iHeight>=0 )

        {

        return aOverridingSize;

        }

    if( aBitmap )

        {

        if( AknIconUtils::IsMifIcon( aBitmap ) )

            {

            TSize svgSize( aTargetLayoutSize );

            // Preserve icon data

            AknIconUtils::PreserveIconData( aBitmap );

            aPreserved = ETrue;

            // Set source rectangle from SVG dimension

            if( AknIconUtils::GetContentDimensions( aBitmap, svgSize ) )

                {

                AKNS_TRACE_ERROR("AknsScalabilityUtils-GetSourceSize GetContentDimensions FAILED!");

                }

            return svgSize;

            }

        else

            {

            // Set source rectangle from bitmap dimension

            return aBitmap->SizeInPixels();

            }

        }

    return aTargetLayoutSize;

    }

void DestroyPreservedIcon( TAny* aBitmap )

    {

    CFbsBitmap* bitmap = static_cast<CFbsBitmap*>(aBitmap);

    if ( bitmap )

        {

        AknIconUtils::DestroyIconData( bitmap );

        }

    }

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

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

// AknsScalabilityUtils::DrawPartialCachedImage

// (commented in the header).

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

//

TBool AknsScalabilityUtils::DrawPartialCachedImageL(

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

    const TRect& aTrgDrawRect, CAknsImageItemData* aImgData,

    const TAknsItemID& /*aIID*/, const TAknsImageAttributeData* aAttr,

    const TInt aDrawParam )

    {

    // Check for empty draw rectangle

    if( aTrgDrawRect.IsEmpty() )

        {

        return ETrue;

        }

    TBool isChained (EFalse);

    if (aImgData && (aDrawParam&KAknsDrawParamChained))

        {

        isChained = ETrue;

        }

    // @TODO KAknsDrawParamAlphaOnly supports only soft masks!

    // Attribute retrieval

    TAknsImageAttributeData attr;

    //lint --e{961} Valid logic

    if( aAttr )

        {

        AKNS_TRACE_INFO("AknsScalabilityUtils::DPCI Using supplied attributes");

        attr.Set( *aAttr );

        }

    else if( aImgData->Attributes() )

        {

        AKNS_TRACE_INFO("AknsScalabilityUtils::DPCI Using data attributes");

        attr.Set( *(aImgData->Attributes()) );

        }

    TAknsItemType type = aImgData->Type();

    // Sanity checks

    if( AknsUtils::IsDerivedType( EAknsITBitmap, type ) )

        {

        if( !static_cast<CAknsBitmapItemData*>(aImgData)->Bitmap() )

            {

            AKNS_TRACE_ERROR("AknsScalabilityUtils::DPCI Bitmap is NULL");

            return EFalse;

            }

        }

    if( AknsUtils::IsDerivedType( EAknsITMaskedBitmap, type ) )

        {

        if( !static_cast<CAknsMaskedBitmapItemData*>(aImgData)->Mask() )

            {

            AKNS_TRACE_ERROR("AknsScalabilityUtils::DPCI Mask is NULL");

            return EFalse;

            }

        }

    // Graphics type detection

    CFbsBitmap* bdBmp = NULL;

    if( AknsUtils::IsDerivedType( EAknsITBitmap, type ) )

        {

        bdBmp = static_cast<CAknsBitmapItemData*>(aImgData)->Bitmap();

        }

    TSize overridingSize( -1, -1 ); // By default there is no overriding size

    // Backward compatibility operations

    if( !(attr.iAttributes&EAknsImageAttributeNBC) )

        {

        // Scale NONE and ALIGNED images to the entire rectangle

        if( (attr.iAttributes==EAknsImageAttributeNone) ||

            (attr.iAttributes&EAknsImageAttributeAlign) )

            {

            AKNS_TRACE_INFO("AknsScalabilityUtils::DPCI BC scale" );

            overridingSize = aTrgLayoutRect.Size();

            }

        }

    // Concrete image layout

    if( attr.iAttributes & EAknsImageAttributeSize )

        {

        overridingSize = attr.iSize;

        }

    if( (attr.iAttributes & EAknsImageAttributeStretch) || 

          (attr.iAttributes & EAknsImageAttributeTileX) ||

            (attr.iAttributes & EAknsImageAttributeTileY) )

        {

        overridingSize = aTrgLayoutRect.Size();

        }

    TBool iconPreserved = EFalse;

    TRect imgRect( aTrgLayoutRect.iTl,

        GetSourceSize( overridingSize, aTrgLayoutRect.Size(), bdBmp, iconPreserved ) );

    if ( iconPreserved )

        {

        // Let's make room to the cleanupstack so that the following TCleanupItem

        // PushL never leaves.

        TRAPD( err,

            CleanupStack::PushL( static_cast<TAny*>(NULL) );

            CleanupStack::Pop(); // NULL

            );

        if ( err )

            {

            iconPreserved = EFalse;

            }

        else

            {

            // Now - this should never leave. Leavescan still complains about this, 

            // but it should be ignored.

            CleanupStack::PushL( TCleanupItem( DestroyPreservedIcon, bdBmp ) );

            }

        }

    if( attr.iAttributes & EAknsImageAttributeCoords )

        {

        imgRect.Move( attr.iCoords );

        }

    if( attr.iAttributes & EAknsImageAttributeAlign )

        {

        switch( attr.iAlignment & EAknsImageAlignVMask )

            {

            case EAknsImageAlignVBottom:

                {

                imgRect.Move( 0, aTrgLayoutRect.Height() - imgRect.Height() );

                break;

                }

            case EAknsImageAlignVCenter:

                {

                // Negative values should not appear, and thus "rounding to

                // the wrong direction" is acceptable.

                imgRect.Move( 0, ( aTrgLayoutRect.Height() -

                    imgRect.Height() ) >> 1 ); //lint !e702

                break;

                }

            default: // incl. EAknsImageAlignVTop

                {

                break;

                }

            } //lint !e788 Default correct for unexpected values

        switch( attr.iAlignment & EAknsImageAlignHMask )

            {

            case EAknsImageAlignHRight:

                {

                imgRect.Move( aTrgLayoutRect.Width() - imgRect.Width(), 0 );

                break;

                }

            case EAknsImageAlignHCenter:

                {

                // Negative values should not appear, and thus "rounding to

                // the wrong direction" is acceptable.

                imgRect.Move( ( aTrgLayoutRect.Width() -

                    imgRect.Width() ) >> 1, 0 ); //lint !e702

                break;

                }

            default: // incl. EAknsImageAlignHLeft

                {

                break;

                }

            } //lint !e788 Default correct for unexpected values

        }

    TRect uncroppedImgRect = imgRect;

    imgRect.Intersection( aTrgLayoutRect );

    AKNS_TRACE_INFO2("AknsScalabilityUtils::DPCI ImgRectSize=%i,%i", imgRect.Size().iWidth, imgRect.Size().iHeight );

    // Drawing

    if( (attr.iAttributes & EAknsImageAttributeTile) ||

        (attr.iAttributes & EAknsImageAttributeTileX) ||

        (attr.iAttributes & EAknsImageAttributeTileY) )

        {

        if( bdBmp )

            {

            TInt setSizeErr( KErrUnknown );

            if( attr.iAttributes & EAknsImageAttributeTile )

                {

                setSizeErr = AknIconUtils::SetSize( bdBmp,

                    uncroppedImgRect.Size(), EAspectRatioNotPreserved );

                }

            else if( attr.iAttributes & EAknsImageAttributeTileX )

                {

                setSizeErr = AknIconUtils::SetSize( bdBmp,

                    TSize( KMaxTInt, aTrgLayoutRect.Height() ),

                    EAspectRatioPreservedAndUnusedSpaceRemoved );

                }

            else if( attr.iAttributes & EAknsImageAttributeTileY )

                {

                setSizeErr = AknIconUtils::SetSize( bdBmp,

                    TSize( aTrgLayoutRect.Width(), KMaxTInt ),

                    EAspectRatioPreservedAndUnusedSpaceRemoved );

                }

            // Destroy icon data

            if ( iconPreserved )

                {

                CleanupStack::PopAndDestroy(); // DestroyPreservedIcon

                }

            if( setSizeErr )

                {

                AKNS_TRACE_ERROR1("AknsScalabilityUtils::DPCI SetSize (in tiling) FAILED, err=%i", setSizeErr);

                return EFalse;

                }

            iconPreserved = EFalse;

            }

        if( aDrawParam&KAknsDrawParamPrepareOnly )

            {

            // Prepare only, return before drawing

            if ( iconPreserved )

                {

                CleanupStack::PopAndDestroy(); // DestroyPreservedIcon

                }

            return ETrue;

            }

        //lint --e{961} Valid logic

        // RGB-only drawing falls to next branch

        if( AknsUtils::IsDerivedType( EAknsITMaskedBitmap, type ) &&

            (!(aDrawParam&KAknsDrawParamRGBOnly)) )

            {

            // This fallback functionality draws tiled masked bitmaps.

            // It's known to be slow - therefore such elements are strongly

            // discouraged.

            CAknsMaskedBitmapItemData* bmpData =

                static_cast<CAknsMaskedBitmapItemData*>(aImgData);

            aGc.SetClippingRect( aTrgDrawRect );

            aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

            TSize tileSize( bmpData->Bitmap()->SizeInPixels() );

            for( int tileY = aTrgLayoutRect.iTl.iY;

                tileY < aTrgLayoutRect.iBr.iY;

                tileY += tileSize.iHeight )

                {

                for( int tileX = aTrgLayoutRect.iTl.iX;

                    tileX < aTrgLayoutRect.iBr.iX;

                    tileX += tileSize.iWidth )

                    {

                    TRect tileRect( TPoint( tileX, tileY ), tileSize );

                    if( !tileRect.Intersects( aTrgDrawRect ) )

                        {

                        // Skip tiles that fall outside the drawing rectangle

                        continue;

                        }

                    if( aDrawParam&KAknsSDMAlphaOnly )

                        {

                        aGc.BitBlt( tileRect.iTl, bmpData->Mask(),

                            TRect( TPoint(0,0), tileSize ) );

                        }

                    else

                        {

                        aGc.BitBltMasked( tileRect.iTl, bmpData->Bitmap(),

                            TRect( TPoint(0,0), tileSize ),

                            bmpData->Mask(), ETrue );

                        }

                    }

                }

            aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

            aGc.CancelClippingRect();

            }

        else if( AknsUtils::IsDerivedType( EAknsITBitmap, type ) )

            {

            if( aDrawParam&KAknsSDMAlphaOnly )

                {

                // Do not draw anything

                if ( iconPreserved )

                    {

                    CleanupStack::PopAndDestroy(); // DestroyPreservedIcon

                    }

                return ETrue;

                }

            CAknsBitmapItemData* bmpData =

                static_cast<CAknsBitmapItemData*>(aImgData);

            aGc.UseBrushPattern( bmpData->Bitmap() );

            aGc.SetBrushOrigin( aTrgLayoutRect.iTl );

            aGc.SetBrushStyle(CGraphicsContext::EPatternedBrush);

            aGc.DrawRect( aTrgDrawRect );

            aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

            aGc.DiscardBrushPattern();

            }

        }

    else

        {

        // Size must be set (to support SVG icons)

        // This also handles stretching of masks transparently

        if( AknsUtils::IsDerivedType( EAknsITBitmap, type ) )

            {

            CAknsBitmapItemData* bmpData =

                static_cast<CAknsBitmapItemData*>(aImgData);

            if( AknIconUtils::SetSize( bmpData->Bitmap(),

                imgRect.Size(), EAspectRatioNotPreserved ) )

                {

                AKNS_TRACE_ERROR("AknsScalabilityUtils::DPCI SetSize FAILED!");

                if ( iconPreserved )

                    {

                    CleanupStack::PopAndDestroy(); // DestroyPreservedIcon

                    }

                return EFalse;

                }

            }

        if( bdBmp )

            {

            // Destroy icon data

            if ( iconPreserved )

                {

                iconPreserved = EFalse;

                CleanupStack::PopAndDestroy(); // DestroyPreservedIcon

                }

            }

        if( aDrawParam&KAknsDrawParamPrepareOnly )

            {

            // Prepare only, return before drawing

            if ( iconPreserved )

                {

                CleanupStack::PopAndDestroy(); // DestroyPreservedIcon

                }

            return ETrue;

            }

        TRect imgDrawRect = imgRect;

        imgDrawRect.Intersection( aTrgDrawRect );

        TPoint imgDrawPoint = imgDrawRect.iTl - uncroppedImgRect.iTl;

        TBool isMasked = AknsUtils::IsDerivedType( EAknsITMaskedBitmap, type);

        CAknsMaskedBitmapItemData* bmpData =

                static_cast<CAknsMaskedBitmapItemData*>(aImgData);

        TRect drawrect = isChained ? TRect( imgDrawPoint + aImgData->DrawRect().iTl,imgDrawRect.Size() ) :

                                     TRect( imgDrawPoint,imgDrawRect.Size() );

        // RGB-only falls to next branch

        if( isMasked && bmpData->Mask()

            && (!(aDrawParam&KAknsDrawParamRGBOnly)) )

            {

            aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

            if( aDrawParam&KAknsSDMAlphaOnly)

                {

                aGc.BitBlt( imgDrawRect.iTl, bmpData->Mask(), drawrect );

                }

            else

                {

                aGc.BitBltMasked( imgDrawRect.iTl, bmpData->Bitmap(), drawrect, bmpData->Mask(), ETrue );

                }

            int m = bmpData->Bitmap()->DisplayMode();

            aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

            }

        else if( AknsUtils::IsDerivedType( EAknsITBitmap, type ) )

            {

            if( aDrawParam&KAknsSDMAlphaOnly )

                {

                // Do not draw anything

                if ( iconPreserved )

                    {

                    AknIconUtils::DestroyIconData( bdBmp );

                    }

                return ETrue;

                }

            CAknsBitmapItemData* bmpData2 =

                static_cast<CAknsBitmapItemData*>(aImgData);

            int m = bmpData2->Bitmap()->DisplayMode();

            aGc.BitBlt(imgDrawRect.iTl, bmpData2->Bitmap(), drawrect );

            }

        }

    return ETrue;

    }

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

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

// CachedLayoutBitmap

//

// Retrieves a cached masked bitmap representing particular layout item

// (or @c NULL if not found).

//

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

//

CAknsImageItemData* CachedLayoutBitmap( CAknsAppSkinInstance* aSkin,

    const TAknsItemID& aIID, const TSize& /*aSize*/,

    const TSize& aLayoutSize, const TInt aLayout, TBool& aMorphingOut, const TBool& aLocalItem )

    {

    return aSkin->GetLayoutBitmap( aIID, aLayoutSize, aLayout, aMorphingOut, aLocalItem );

    }

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

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

// AknsScalabilityUtils::ProcessDefL

// (commented in the header).

// If additional handling is added - then might leave. Leave indication 'L'

// left for future purposes.

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

//

CAknsItemDef* AknsScalabilityUtils::ProcessDefL( CAknsItemDef* aDef )

    {

    // INSERTION POINT for any additional handling

    return aDef;

    }

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

// AknsScalabilityUtils::ConvertToBitmap

// (commented in the header).

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

//