/*

* Copyright (c) 2009 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:

* CWmImageConverter implementation

*

*/

#include <fbs.h>

#include <eikdef.h>

#include <eikenv.h>

#include <bautils.h>

#include <imageconversion.h>

#include <bitmaptransforms.h>

#include <AknIconUtils.h>

#include <AknsSkinInstance.h>

#include <AknsUtils.h>

#include <avkon.mbg>

#include <apgcli.h>

#include <SVGEngineInterfaceImpl.h>

#include <widgetregistryconstants.h> // KWidgetUidLowerBound, KWidgetUidUpperBound

#include "wmimageconverter.h"

_LIT( KSkin, 		  "skin" );

_LIT( KMif, 		  "mif" );

_LIT( KUid,           "uid" );

_LIT( KColon,		  ":" );

_LIT( KSvgExt,        ".svg" );

_LIT( KHexPrefix,     "0x" );

const TUint KLeftParenthesis = '(';

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

// CWmImageConverter::NewL

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

//

CWmImageConverter* CWmImageConverter::NewL()

    {

    CWmImageConverter* self = 

        new(ELeave) CWmImageConverter();

    CleanupStack::PushL( self );    

    self->ConstructL();

    CleanupStack::Pop(self);

    return self; 

    }

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

// CWmImageConverter::CWmImageConverter 

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

//

CWmImageConverter::CWmImageConverter() 

    {

    iBitmap = NULL;

    iMask = NULL;

    }

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

// CWmImageConverter::ConstructL

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

//

void CWmImageConverter::ConstructL()

    {

    User::LeaveIfError( iFs.Connect() );

    iFs.ShareProtected();

    }

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

// CWmImageConverter::~CWmImageConverter

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

//

CWmImageConverter::~CWmImageConverter()

    {

    iFs.Close(); 

    if ( iBitmap ) 

        {

        delete iBitmap;

        iBitmap = NULL;

        }

    if ( iMask )

        {

        delete iMask; 

        iMask = NULL;

        }

    }

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

// CWmImageConverter::HandleIconString

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

//

TInt CWmImageConverter::HandleIconString( 

                            const TSize& aIconSize, 

                            const TDesC& aIconStr,

                            CFbsBitmap*& aBitmap,

                            CFbsBitmap*& aMask )

    {

    delete aBitmap; aBitmap = NULL;

    delete aMask; aMask = NULL;

    TInt err( KErrNone );

    TRAP( err, HandleIconStringL( aIconSize, aIconStr ); );

    if ( err == KErrNone && iBitmap && iMask )

        {

        // ownership transferred

        aBitmap = iBitmap;

        iBitmap = NULL;

        aMask = iMask;        

        iMask = NULL;

        }

    else

        {

        if ( iBitmap ) 

            {

            delete iBitmap;

            iBitmap = NULL;

            }

        if ( iMask )

            {

            delete iMask; 

            iMask = NULL;

            }

        }

    return err;

    }

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

// CWmImageConverter::HandleIconStringL

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

//

void CWmImageConverter::HandleIconStringL( 

                            const TSize& aIconSize, 

                            const TDesC& aIconStr )

    {

    if ( aIconStr.Length() )

        {

        TAknsItemID skinItemId;

        skinItemId.iMajor = 0;

        skinItemId.iMinor = 0;

        TInt bitmapId( KErrNotFound );

        TInt maskId( KErrNotFound );

        TUid appUid;

        iFilename = KNullDesC;

        iSize = aIconSize;

        if ( ResolveSkinIdAndMifId( 

                aIconStr, skinItemId, bitmapId, maskId, iFilename ) )

            {

            CreateSkinOrMifIconL( 

                    skinItemId, bitmapId, maskId, iFilename );

            }

        else if ( ResolveUid( aIconStr, appUid ) )

            {

            CreateIconFromUidL( appUid );

            }

        else if ( EndsWith( aIconStr, KSvgExt ) )

            {

            // filename_with_full_path.svg

            CreateIconFromSvgL( aIconStr );

            }

        else if ( BaflUtils::FileExists( iFs, aIconStr ) )

            {

            // filename_with_full_path.png/jpg

            CreateIconFromOtherL( aIconStr );

            }

        else

            {

            User::Leave( KErrArgument );

            }

        }

    else

        {            

        User::Leave( KErrArgument );

        }

    }

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

// CWmImageConverter::CreateIconFromUidL

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

//

void CWmImageConverter::CreateIconFromUidL( const TUid& aUid )

    {

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    if ( aUid.iUid >= KWidgetUidLowerBound &&

       aUid.iUid < KWidgetUidUpperBound  )

        {

        RApaLsSession lsSession;

        User::LeaveIfError( lsSession.Connect() );

        CleanupClosePushL( lsSession );

        const TInt KAppSizeArraySize = 3;

        CArrayFixFlat<TSize>* sizeArray = new (ELeave)

            CArrayFixFlat<TSize>( KAppSizeArraySize );

        CleanupStack::PushL( sizeArray );

        User::LeaveIfError( lsSession.GetAppIconSizes( aUid, *sizeArray ) );

        // there should be atleast one size available

        if ( sizeArray->Count() == 0 ){ User::Leave( KErrNotReady ); };

        TSize size(0,0);

        for( TInt i=0; i < sizeArray->Count(); i++ )

            {

            TSize s = (*sizeArray)[i];

            if ( size.iWidth < s.iWidth || size.iHeight < s.iHeight )

                { size = s; }

            if ( size == iSize ) { break; }

            }

        CApaMaskedBitmap* maskedBmp = CApaMaskedBitmap::NewLC();

        User::LeaveIfError( lsSession.GetAppIcon( aUid, size, *maskedBmp ) );

        // handle bitmap

        iBitmap = new ( ELeave ) CFbsBitmap;       

        CopyBitmapL( *iBitmap, *maskedBmp );

        // handle mask

        if ( maskedBmp->Mask() )

            {

            iMask = new ( ELeave ) CFbsBitmap;

            CopyBitmapL( *iMask, *maskedBmp->Mask() );

            }

        // cleanup

        CleanupStack::PopAndDestroy( maskedBmp );

        CleanupStack::PopAndDestroy( sizeArray ); 

        CleanupStack::PopAndDestroy( &lsSession );

        }

    else if ( aUid.iUid != KNullUid.iUid )

        {

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        TInt err( KErrNone );

        TRAP( err,

                {

                AknsUtils::CreateAppIconLC( skin, aUid,

                        EAknsAppIconTypeContext, bitmap, mask );

                CleanupStack::Pop( 2 ); // for trap

                }

            );

        if( KErrNone != err )

            {

            // If icon is not created, try to create default application icon

            AknsUtils::CreateIconLC( skin,

                KAknsIIDQgnMenuUnknownLst, bitmap, mask,

                AknIconUtils::AvkonIconFileName(),

                EMbmAvkonQgn_menu_unknown_lst,

                EMbmAvkonQgn_menu_unknown_lst_mask );

            CleanupStack::Pop( 2 ); // for trap

            }

        iBitmap = bitmap;

        iMask = mask;

        err = AknIconUtils::SetSize( iBitmap , iSize, EAspectRatioPreserved );

        if ( KErrNone == err )

            {

            err = AknIconUtils::SetSize( iMask , iSize, EAspectRatioPreserved );

            }

        }

    else

        {

        User::Leave( KErrArgument );

        }

    }

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

// CWmImageConverter::CreateIconFromSvgL

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

//

void CWmImageConverter::CreateIconFromSvgL( const TDesC& aFileName )

    {

    if ( iBitmap )

        {

        delete iBitmap;

        iBitmap = NULL;

        }

    if ( iMask )

        {

        delete iMask;

        iMask = NULL;

        }

    TDisplayMode mode = CEikonEnv::Static()->ScreenDevice()->DisplayMode();

    if ( mode >= ERgb ) // currently svg engine doesn't render correctly

        { mode = EColor16M; } // in this or above mode ( ou1cimx1#229434 )

    TFontSpec fontspec;

    CFbsBitmap* frameBuffer = new ( ELeave ) CFbsBitmap;

    CleanupStack::PushL( frameBuffer );

    frameBuffer->Create( iSize, mode );

    CSvgEngineInterfaceImpl* svgEngine = CSvgEngineInterfaceImpl::NewL( 

            frameBuffer, NULL, fontspec );

    CleanupStack::PushL( svgEngine );

    svgEngine->SetDRMMode( EFalse );

    TInt domHandle;

    CheckSvgErrorL( svgEngine->PrepareDom( aFileName, domHandle ) );

    CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;    

    CleanupStack::PushL( bitmap );

    User::LeaveIfError( bitmap->Create( iSize, mode ) );

    CFbsBitmap* mask = new(ELeave) CFbsBitmap;    

    CleanupStack::PushL( mask );

    User::LeaveIfError( mask->Create( iSize, EGray256 ) );

    CheckSvgErrorL( svgEngine->UseDom( domHandle, bitmap, mask ) );

    MSvgError* err;

    svgEngine->Start( err );

    CheckSvgErrorL( err );

    CheckSvgErrorL( svgEngine->UseDom( domHandle, NULL, NULL ) );

    CheckSvgErrorL( svgEngine->DeleteDom( domHandle ) );

    CleanupStack::Pop( mask );

    CleanupStack::Pop( bitmap );

    CleanupStack::PopAndDestroy( svgEngine );

    CleanupStack::PopAndDestroy( frameBuffer );

    iBitmap = bitmap;

    iMask = mask;

    }

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

// CWmImageConverter::CreateIconFromOtherL

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

//

void CWmImageConverter::CreateIconFromOtherL( const TDesC& aFileName )

    {

    if (iBitmap) {delete iBitmap; iBitmap = NULL;}

    if (iMask) {delete iMask; iMask = NULL;}

    iFilename.Copy( aFileName );

    // create the decoder

    CImageDecoder* imageDecoder = CImageDecoder::FileNewL( 

            iFs, iFilename, CImageDecoder::EOptionAlwaysThread );

    CleanupStack::PushL( imageDecoder );

    TSize size = imageDecoder->FrameInfo().iOverallSizeInPixels;

    // create the destination bitmap

    iBitmap = new (ELeave) CFbsBitmap();

    User::LeaveIfError( iBitmap->Create( 

            size, imageDecoder->FrameInfo().iFrameDisplayMode ) ); 

    iMask = new (ELeave) CFbsBitmap();

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

    // start conversion to bitmap

    TRequestStatus status;

    imageDecoder->Convert( &status, *iBitmap, *iMask );

    User::WaitForRequest( status );

    if( status.Int() == KErrUnderflow ) 

        {

        imageDecoder->ContinueConvert( &status );

        User::WaitForRequest( status );

        }

    User::LeaveIfError( status.Int() );    

    CleanupStack::PopAndDestroy( imageDecoder );

    }

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

// CWmImageConverter::CreateSkinOrMifIconL

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

//

void CWmImageConverter::CreateSkinOrMifIconL( 

                const TAknsItemID& aItemId, TInt aBitmapId, 

                TInt aMaskId, const TDesC& aFileName )

    {

    iFilename = aFileName;

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    // Load from skin 

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if ( skin && aItemId.iMajor != 0 && aItemId.iMinor != 0 )

        {

        TInt err( KErrNone );

        CAknsMaskedBitmapItemData* itemData = NULL;

        TRAP( err, itemData = 

                    static_cast<CAknsMaskedBitmapItemData*>(

                    skin->CreateUncachedItemDataL( aItemId, EAknsITMaskedBitmap ) ); );

        if( itemData && KErrNone == err )

            {

            CleanupStack::PushL( itemData );

            // Detach bitmaps

            bitmap = itemData->Bitmap();

            itemData->SetBitmap( NULL );

            mask = itemData->Mask();

            itemData->SetMask( NULL );

            CleanupStack::PopAndDestroy( itemData );

            }

        else

            {

            // look in imagetable

            CAknsImageTableItemData* iconData = NULL;

            TRAP( err, iconData = static_cast<CAknsImageTableItemData*>(

                            skin->CreateUncachedItemDataL( aItemId, EAknsITImageTable ) ); );

            if( iconData && KErrNone == err )

                {

                CleanupStack::PushL( iconData );

                if( iconData->NumberOfImages() )

                    {                        

                    TAknsItemID iconIId;

                    iconIId.Set( iconData->ImageIID(0) );

                    TRAP( err, AknsUtils::CreateIconL( 

                            skin, iconIId, bitmap, mask, KNullDesC, -1, -1 ); );

                    }

                CleanupStack::PopAndDestroy( iconData );

                }

            }

        if ( KErrNone == err && bitmap )

            {

            TInt err = AknIconUtils::SetSize( 

                    bitmap, 

                    iSize, 

                    EAspectRatioPreserved );

            if ( KErrNone == err  )

                {

                if ( mask )

                    {

                    err = AknIconUtils::SetSize( 

                            mask, 

                            iSize, 

                            EAspectRatioPreserved );

                    }

                iBitmap = bitmap;

                iMask = mask;

                return;

                }

            else

                {

                if ( bitmap ) { delete bitmap; bitmap = NULL; }

                if ( mask ){ delete mask; mask = NULL; }

                }

            }

        }

    if( aBitmapId != KErrNotFound && !bitmap && 

       aFileName.Length() && BaflUtils::FileExists( iFs, aFileName ) )

        {

        if ( aMaskId != KErrNotFound )

          {

          // Create icon from Mif filename , bitmap id and mask id          

          AknIconUtils::CreateIconL(

                  bitmap, mask, *this, aBitmapId, aMaskId );

          }

        else

          {

          bitmap = AknIconUtils::CreateIconL( *this, aBitmapId );

          }

        }

    else

        {

        User::Leave( KErrArgument );

        }

    iBitmap = bitmap;

    iMask = mask;

    TInt err = AknIconUtils::SetSize( iBitmap , iSize, EAspectRatioPreserved );

    if ( KErrNone == err && iMask )

        {

        err = AknIconUtils::SetSize( iMask , iSize, EAspectRatioPreserved );

        }

    }

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

// CWmImageConverter::CheckSvgErrorL

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

//

void CWmImageConverter::CheckSvgErrorL( MSvgError* aError )

    {

    if ( aError )

        {

        User::LeaveIfError( aError->SystemErrorCode() );

        }

    }

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

// CWmImageConverter::EndsWith

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

//

TBool CWmImageConverter::EndsWith( const TDesC& aString, 

                                const TDesC& aPattern )

    {

    return ( aString.Right( aPattern.Length() ) == aPattern );

    }

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

// CWmImageConverter::ResolveUid

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