/*

* 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:  Extension to AknsUtils.

*

*/

// INCLUDE FILES

#include "AknsCppPreface.h"

#include <apgcli.h>

#include <AknIconUtils.h>

#include <avkon.mbg>

#include <AknsUtils.h>

#include "AknsJavaUtils.h"

#include <AknsItemData.h>

#include "AknsAppSkinInstance.h"

#include <AknsImageAttributeData.h>

#include "AknsDebug.h"

#include "AknInternalIconUtils.h"

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

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

// AknsUtils::CreateAppIconLC

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

//

AKNS_EXPORTED_METHOD(AknsUtils::CreateAppIconLC)

EXPORT_C void AknsUtils::CreateAppIconLC(

    MAknsSkinInstance* aInstance, TUid aAppUid,

    TAknsAppIconType aType,

    CFbsBitmap*& aBitmap, CFbsBitmap*& aMask )

    {

    aBitmap = NULL;

    aMask = NULL;

    if (!aInstance)

        {

        User::Leave(KErrArgument);

        }

    TSize legacySize( 42, 29 );

    TInt bitmapIndex( 0 );

    TInt maskIndex( 1 );

    if( aType == EAknsAppIconTypeContext )

        {

        legacySize = TSize( 44, 44 );

        bitmapIndex = 2;

        maskIndex = 3;

        }

    else if( aType != EAknsAppIconTypeList )

        {

        User::Leave( KErrArgument );

        }

    // Make the forthcoming pushes safe (up to level 2)

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

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

    CleanupStack::Pop( 2 );

    // 1. Check if the icon has been configured.

    TInt ret = KErrNone;

    TBool configuredIcon = EFalse;

    //

    CAknsAppSkinInstance* apskin = static_cast<CAknsAppSkinInstance*>(aInstance);

    if ( apskin )

        {

        TInt config = apskin->IsIconConfiguredL( aAppUid );

        if ( config > 0 )

        configuredIcon = ETrue;

        }

    if ( !configuredIcon )

        {

        // 2. Skin-originating icon

        ret = GetAppIconFromSkin( aInstance, aAppUid, legacySize, aBitmap, aMask );

        if( ret == KErrNone )

            {

            // These pushes are safe

            CleanupStack::PushL( aBitmap ); // (1)

            CleanupStack::PushL( aMask ); // (2)

            return;

            }

        }

    // Cache connected apparc session for future reuse, if not already cached

    // This is done per appskininstance when necessary...

    if (!apskin->iCachedApaSession)

        {

        apskin->iCachedApaSession = new (ELeave) RApaLsSession;

        User::LeaveIfError(apskin->iCachedApaSession->Connect());

        }

    RApaLsSession* lsSession = apskin->iCachedApaSession;

    TBool forceDefaultIcon = EFalse;

    TApaAppInfo appInfo;

    TFileName filename;

    // 3. New appicon framework

    HBufC* filenameBuf = NULL;

    TBool javaIcon = EFalse;

    ret = lsSession->GetAppIcon( aAppUid, filenameBuf );

    if( filenameBuf )

        {

        filename.Copy( *filenameBuf );

        delete filenameBuf;

        }

    if( ret == KErrNone )

        {

        ret = lsSession->GetAppInfo( appInfo, aAppUid );

        }

    if( (ret==KErrNone) && (filename.Length()>2) &&

        (appInfo.iFullName.Length()>2) )

        {

        // Correct drive letter, if necessary

        if( appInfo.iFullName[1]==':' )

            {

            if( filename[1]==':' )

                {

                filename[0] = appInfo.iFullName[0];

                }

            else if( filename[0]=='\\' )

                {

                filename.Insert( 0, appInfo.iFullName.Left(2) );

                }

            }

        // check if the icon is java icon

        javaIcon = AknsJavaUtils::IsJavaIcon(filename);

        if( AknIconUtils::IsMifFile( filename ) )

            {

            // SVG icon

            // SVG always has only one icon

            bitmapIndex = 0;

            maskIndex = 1;

            AknIconUtils::ValidateLogicalAppIconId( filename,

                bitmapIndex, maskIndex );

            if (javaIcon)

                {

                AknsJavaUtils::CreateIconLC(*lsSession, aAppUid, aBitmap,

                    aMask, bitmapIndex, maskIndex ); // aBitmap, aMask (2)

                }

            else

                {

                AknIconUtils::CreateIconLC( aBitmap, aMask, filename,

                    bitmapIndex, maskIndex ); // aBitmap, aMask (2)

                }

            AknInternalIconUtils::SetAppIcon(aBitmap); //icon case

            return;

            }

        else

            {

            // MBM icon

            AknIconUtils::ValidateLogicalAppIconId( filename,

                bitmapIndex, maskIndex );

            TRAP( ret, AknIconUtils::CreateIconL( aBitmap, aMask, filename,

                bitmapIndex, maskIndex ) );

            if( ret == KErrNone )

                {

                // These pushes are safe

                CleanupStack::PushL( aBitmap ); // (1)

                CleanupStack::PushL( aMask ); // (2)

                }

            else

                {

                bitmapIndex = 0;

                maskIndex = 1;

                AknIconUtils::ValidateLogicalAppIconId( filename,

                    bitmapIndex, maskIndex );

                AknIconUtils::CreateIconLC( aBitmap, aMask, filename,

                    bitmapIndex, maskIndex ); // aBitmap, aMask (2)

                }

            AknInternalIconUtils::SetAppIcon(aBitmap); //icon case

            return;

            }

        }

    else if( ret!=KErrNotSupported )

        {

        // New framework, but no icon defined

        forceDefaultIcon = ETrue;

        }

    CApaMaskedBitmap* apaBmp = CApaMaskedBitmap::NewLC(); // apaBmp (1)

    // 3. Old (AIF-based) framework

    if( !forceDefaultIcon )

        {

        TInt apaErr = lsSession->GetAppIcon( aAppUid, legacySize, *apaBmp );

        // Use default icon if APPARC did not initialize icon bitmaps

        if( apaErr || (!apaBmp) || (!apaBmp->Mask()) ||

            (!apaBmp->Handle()) || (!apaBmp->Mask()->Handle()) )

            {

            forceDefaultIcon = ETrue;

            }

        }

    if( forceDefaultIcon )

        {

        // Default icon

        CleanupStack::PopAndDestroy( 1 ); // apaBmp (0)

        TAknsItemID iid = KAknsIIDQgnMenuUnknownLst;

        bitmapIndex = EMbmAvkonQgn_menu_unknown_lst;

        maskIndex = EMbmAvkonQgn_menu_unknown_lst_mask;

        if( aType == EAknsAppIconTypeContext )

            {

            iid = KAknsIIDQgnMenuUnknownCxt;

            bitmapIndex = EMbmAvkonQgn_menu_unknown_cxt;

            maskIndex = EMbmAvkonQgn_menu_unknown_cxt_mask;

            }

        AknsUtils::CreateIconLC( aInstance, iid, aBitmap, aMask,

            AknIconUtils::AvkonIconFileName(), bitmapIndex, maskIndex ); // aBitmap, aMask (2)

        }

    else

        {

        // AIF-based icon

        CFbsBitmap* iconOwnedBitmap = new (ELeave) CFbsBitmap();

        CleanupStack::PushL( iconOwnedBitmap ); // iob (3)

        CFbsBitmap* iconOwnedMask = new (ELeave) CFbsBitmap();

        CleanupStack::PushL( iconOwnedMask ); // iom (4)

        User::LeaveIfError(

            iconOwnedBitmap->Duplicate( apaBmp->Handle() ) );

        User::LeaveIfError(

            iconOwnedMask->Duplicate( apaBmp->Mask()->Handle() ) );

        CAknIcon* tmpIcon = CAknIcon::NewL();

        CleanupStack::Pop( 2 ); // iom, iob (2)

        CleanupStack::PopAndDestroy( 1 ); // apaBmp (0)

        // Ownership is transferred

        tmpIcon->SetBitmap( iconOwnedBitmap );

        tmpIcon->SetMask( iconOwnedMask );

        // Ownership of tmpIcon is transferred

        CAknIcon* appIcon = AknIconUtils::CreateIconL( tmpIcon );

        aBitmap = appIcon->Bitmap();

        aMask = appIcon->Mask();

        // Detach and delete

        appIcon->SetBitmap( NULL );

        appIcon->SetMask( NULL );

        delete appIcon;

        // These are both safe

        CleanupStack::PushL( aBitmap ); // (1)

        CleanupStack::PushL( aMask ); // (2)

        }

    }

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

// AknsUtils::OpenAppIconFile

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

//

AKNS_EXPORTED_METHOD(AknsUtils::OpenAppIconFile)

EXPORT_C TInt AknsUtils::OpenAppIconFile(

    MAknsSkinInstance* /*aInstance*/, TUid /*aAppUid*/,

    TAknsAppIconType aType, RFile& /*aFile*/ )

    {

    if( aType != EAknsAppIconType3D )

        {

        return KErrArgument;

        }

    return KErrNotSupported;

    }

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

// AknsUtils::GetAppIcon

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

//

AKNS_EXPORTED_METHOD(AknsUtils::GetAppIcon)

EXPORT_C TInt AknsUtils::GetAppIcon(

    MAknsSkinInstance* aInstance, TUid aAppUid, TSize aSize,

    CApaMaskedBitmap& aAppBitmap )

    {

    AKNS_TRACE_OBSOLETE("AknsUtils::GetAppIcon (4 param)");

    __ASSERT_DEBUG( aAppBitmap.Mask(),

        AKNS_DEBUG_PANIC( EAknsDPanicInvalidParameter ) );

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    TInt ret = KErrNone;

    TBool configuredIcon = EFalse;

    if ( !configuredIcon )

        {

        ret = GetAppIconFromSkin( aInstance, aAppUid, aSize, bitmap, mask );

        if( ret == KErrNone )

            {

            if( bitmap && mask && bitmap->Handle() && mask->Handle() )

                {

                ret = aAppBitmap.Duplicate( bitmap->Handle() );

                ret |= aAppBitmap.Mask()->Duplicate( mask->Handle() );

                delete bitmap;

                delete mask;

                return ret;

                }

            else

                {

                // Delete bitmaps and proceed

                delete bitmap;

                bitmap = NULL; 

                delete mask;

                mask = NULL; 

                }

            }

        }

    RApaLsSession lsSession;

    ret = lsSession.Connect();

    if( ret == KErrNone )

        {

        ret = lsSession.GetAppIcon( aAppUid, aSize, aAppBitmap );

        lsSession.Close();

        if(ret == KErrNone) //icon case

        	AknInternalIconUtils::SetAppIcon(bitmap); //icon case

        }

    return ret;

    } //lint !e1746 GetAppIcon syntax

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

// AknsUtils::GetAppIconFromSkin

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

//

TInt AknsUtils::GetAppIconFromSkin(

    MAknsSkinInstance* aInstance, TUid aAppUid, TSize aSize,

    CFbsBitmap*& aBitmap, CFbsBitmap*& aMask )

    {

    if( !aInstance )

        {

        return KErrNotSupported;

        }

    TAknsItemID iid;

    iid.Set( EAknsMajorAppIcon, aAppUid.iUid );

    TInt err( KErrNone );

    TAknsItemID iconIID;

    TRAP( err, ( iconIID = SelectBestAppIconBitmapL(

        aSize, aInstance, iid ) ) );

    if( err )

        {

        return err;

        }

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    TRAPD( createErr,

        CreateIconL( aInstance, iconIID, bitmap, mask, KNullDesC, -1, -1 ) ); //lint !e645 Initialized

    if( createErr )

        {

        delete bitmap;

        delete mask;

        return createErr;

        }

    __ASSERT_DEBUG( bitmap && mask,

        AKNS_DEBUG_PANIC( EAknsDPanicNotInitialized ) );

	AknInternalIconUtils::SetAppIcon(aBitmap); //icon case

    aBitmap = bitmap;

    aMask = mask;

    return KErrNone;

    } //lint !e1746 GetAppIcon syntax

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

// AknsUtils::SelectBestAppIconBitmapL

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

//

TAknsItemID AknsUtils::SelectBestAppIconBitmapL(

    const TSize& aSize,

    MAknsSkinInstance* aSkin,

    const TAknsItemID& aAppIconIID )

    {

    TAknsItemID iid;

    iid.Set( KAknsIIDNone );

    TInt i;

    CAknsImageTableItemData* iconData = static_cast<CAknsImageTableItemData*>(

        aSkin->CreateUncachedItemDataL( aAppIconIID, EAknsITImageTable ) );

    if( !iconData )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PushL( iconData );

    TInt numberOfIcons = iconData->NumberOfImages();

    RArray<TSize> sizeArray;

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

        {

        TBool defOwned = EFalse;

        CAknsImageItemDef* def =

            static_cast<CAknsImageItemDef*>(

            static_cast<CAknsAppSkinInstance*>(aSkin)->LookupDef(

            defOwned, iconData->ImageIID(i), EAknsITImage ) );

        TBool appendError = EFalse;

        if( def && def->Attributes() )

            {

            TSize imageSize = def->Attributes()->iSize;

            if( sizeArray.Append( imageSize ) != KErrNone )

                {

                appendError = ETrue;

                }

            }

        else

            {

            appendError = ETrue;

            }

        if( defOwned )

            {

            delete def;

            def = NULL;

            }

        if( appendError )

            {

            sizeArray.Reset();

            User::Leave( KErrGeneral );

            }

        }

    CleanupStack::Pop( iconData );

    // First check for zero size (SVG) or the exact match

    TInt indexFound = -1;

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

        {

        if( (sizeArray[i].iWidth==aSize.iWidth) &&

            (sizeArray[i].iHeight==aSize.iHeight) )

            {

            AKNS_TRACE_INFO2("AknsUtils::SBAIB Found (exact) MBM appicon for %x %x", aAppIconIID.iMinor, aAppIconIID.iMajor );

            indexFound = i;

            // Do not break, (0,0) might still be there

            }

        else if( (sizeArray[i].iWidth==0) &&

            (sizeArray[i].iHeight==0) )

            {

            AKNS_TRACE_INFO2("AknsUtils::SBAIB Using SVG appicon for %x %x", aAppIconIID.iMinor, aAppIconIID.iMajor );

            indexFound = i;

            break;

            }

        }

    if( indexFound>-1 )

        {

        iid.Set( iconData->ImageIID( indexFound ) );

        sizeArray.Reset();

        delete iconData;

        return iid;

        }

    // Then the largest of smaller or (in terms of one dimension) equal icons

    TInt bestDSum = 0;

    TInt dSum;

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

        {

        if( (sizeArray[i].iWidth<=aSize.iWidth) &&

            (sizeArray[i].iHeight<=aSize.iHeight) )

            {

            dSum = sizeArray[i].iWidth + sizeArray[i].iHeight;

            if( dSum > bestDSum )

                {

                indexFound = i;

                bestDSum = dSum;

                }

            }

        }

    if( indexFound>-1 )

        {

        iid.Set( iconData->ImageIID( indexFound ) );

        sizeArray.Reset();

        delete iconData;

        return iid;

        }

    // Finally, the smallest absolute difference

    bestDSum = KMaxTInt;

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

        {

        dSum = ( sizeArray[i].iWidth * sizeArray[i].iHeight ) -

            (aSize.iWidth*aSize.iHeight);

        if( dSum < 0 )

            {

            dSum = 0-dSum;

            }

        if( dSum < bestDSum )

            {

            indexFound = i;

            bestDSum = dSum;

            }

        }

    if( indexFound>-1 )

        {

        iid.Set( iconData->ImageIID( indexFound ) );

        }

    sizeArray.Reset();

    delete iconData;

    if( indexFound<0 )

        {

        User::Leave( KErrNotFound );

        }