/*

* Copyright (c) 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:  The API supports requesting raw bitmaps

*  Version     :  %version: 11 % << Don't touch! Updated by Synergy at check-out.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <AknsUtils.h> 

#include <mcsmenu.h>

#include <mcsmenuitem.h>

#include <mcsmenuutils.h>

#include <SATDomainPSKeys.h>

#include <e32property.h>

#include <apgcli.h>

#include <AknInternalIconUtils.h>

#include "mcssathandler.h"

//#include "mcsextendedmenuitem.h"

#include "mcsmenuiconutility.h"

#include <mcsdef.h>

// Constants

_LIT( KMifIconPath, "\\resource\\apps\\" );

const TUint32 KMifIconPathLenght = 18;

const TInt KJavaIconWidth = 88;			// Java icon default width

const TInt KJavaIconHeight = 88;		// Java icon default height

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

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

// CreateMbmIconLC2 - Creates bitmap

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

//    

LOCAL_C TBool CreateMbmIconLC2(CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, const TDesC& aAppUid ) 

    {

    TBool ret = EFalse;

    TSize size( KJavaIconWidth, KJavaIconHeight );

    aBitmap = NULL;

    aMask = NULL;

    RApaLsSession lsSession;

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

    CleanupClosePushL( lsSession ); // lsSession (1)

    TUint appUidUint;

    // Gets app TUid from aAppUid descryptor

    User::LeaveIfError( MenuUtils::GetTUint( aAppUid, appUidUint ) );

    TUid appUid( TUid::Uid( appUidUint) );

    // Tries to find icon with default size.

    CApaMaskedBitmap* apaBmp = CApaMaskedBitmap::NewLC();

    TInt apaErr = lsSession.GetAppIcon( appUid, size, *apaBmp );

    if ( apaErr == KErrNotFound ) 

        {

        // Icon not found.

        // AppArc tries to find equal to or smaller than the specified size.

        // Get all icon sizes and search for next bigger icon size.

        CArrayFixFlat<TSize>* sizes = new(ELeave) CArrayFixFlat<TSize>( 5 );

        apaErr = lsSession.GetAppIconSizes(appUid, *sizes);

        if ( !apaErr )

            {

            if ( sizes->Count() ) 

                {

                // There are other icon sizes

                TInt idx = -1;

                TInt square( size.iWidth * size.iHeight );

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

                    {

                    if ( ( sizes->At( i ).iWidth * sizes->At( i ).iHeight ) > square ) 

                        {

                        idx = i;

                        break;

                        }

                    }

                if ( idx >= 0 ) 

                    {

                    // Next bigger icon.

                    size = sizes->At( idx );

                    }

                else 

                    {

                    // Just get the first available.

                    size = sizes->At( 0 );

                    }

                }

            // Gets icon with new size.

            apaErr = lsSession.GetAppIcon( appUid, size, *apaBmp );

            }

        // Reset and destroy.

        sizes->Reset();

        delete sizes;

        sizes = NULL;

        }

    // Some builds requires brackets

    // logical correction was also made

    if ( ( apaErr != KErrNone ) &&

         ( apaErr != KErrNotFound ) &&

         ( apaErr != KErrNotSupported ) ) 

        {

        // System wide error.

        User::LeaveIfError( apaErr );

        }

    if( !apaErr && 

        apaBmp && 

        apaBmp->Mask() &&

        apaBmp->Handle() && 

        apaBmp->Mask()->Handle()) 

        {

        // 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();

        // Ownership is transferred

        tmpIcon->SetBitmap( iconOwnedBitmap );

        tmpIcon->SetMask( iconOwnedMask );

        // Ownership of tmpIcon is transferred

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

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

        aBitmap = appIcon->Bitmap();

        aMask = appIcon->Mask();

        AknInternalIconUtils::SetAppIcon(aBitmap);

        // Detach and delete

        appIcon->SetBitmap( NULL );

        appIcon->SetMask( NULL );

        delete appIcon;

        ret = ETrue;

        }

    CleanupStack::PopAndDestroy( 2 ); // lsSession, apaBmp (0)

    // These are both safe

    if ( aBitmap ) 

        {

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

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

        }

    return ret;

    }

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

// ParseIconFilePathL

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

//

LOCAL_C void ParseIconFilePathL( const TDesC& aIconFilePath, RBuf& aIconFilePathBuf )

	{

	TParsePtrC fileParsePtrC(aIconFilePath);

	if( !fileParsePtrC.PathPresent())

		{

		aIconFilePathBuf.CreateL(KMifIconPathLenght + aIconFilePath.Length());

		aIconFilePathBuf.Append(KMifIconPath);

		}

	else 

	    {

		aIconFilePathBuf.CreateL(aIconFilePath.Length());

	    }

	aIconFilePathBuf.Append(aIconFilePath);

	}

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

// LoadSkinL

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

//

LOCAL_C CAknIcon* LoadSkinL( TUint majorId, TUint minorId )

    {

    CAknIcon* icon = NULL;

    CFbsBitmap* bitmap( 0 );

    CFbsBitmap* mask( 0 );

    TAknsItemID skinId;

    skinId.Set( majorId, minorId );

    AknsUtils::CreateIconLC(

        AknsUtils::SkinInstance(),

        skinId,

        bitmap,

        mask,

        KNullDesC,

        KErrNotFound,

        KErrNotFound );

    icon = CAknIcon::NewL();

    icon->SetBitmap( bitmap );

    icon->SetMask( mask );

     // bitmap and icon, AknsUtils::CreateIconLC doesn't specify the order

    CleanupStack::Pop( 2 );

    return icon;

    }

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

// LoadSkinL

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

//

LOCAL_C CAknIcon* LoadAppSkinL( TUid& aAppUid )

    {

    CAknIcon* icon = NULL;

    CFbsBitmap* bitmap( 0 );

    CFbsBitmap* mask( 0 );

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TRAPD( err,  

        { 

        AknsUtils::CreateAppIconLC( skin, aAppUid, EAknsAppIconTypeList, bitmap, mask );            

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

       }

        );

    if( err == KErrNone )

        {

        icon = CAknIcon::NewL();

        icon->SetBitmap( bitmap );

        icon->SetMask( mask );

        }

    return icon;

    }

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

// GetSkinL

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

//

LOCAL_C CAknIcon* GetSkinL( CMenuItem& aItem )

	{

	CAknIcon* icon = NULL;

	TUint majorId( 0 );

    TUint minorId( 0 );

    TPtrC idString( KNullDesC );

    TBool attrExists;

	idString.Set( aItem.GetAttributeL( KMenuAttrIconSkinMajorId, attrExists ) );

	if ( attrExists && idString.Length() )

		{

		User::LeaveIfError( MenuUtils::GetTUint( idString, majorId ) );

		}

	else

		{

		return NULL;

		}

	idString.Set( aItem.GetAttributeL( KMenuAttrIconSkinMinorId, attrExists ) );

	if ( attrExists && idString.Length() )

		{

		User::LeaveIfError( MenuUtils::GetTUint( idString, minorId ) );

		}

	else

		{

		return NULL;

		}

	icon = LoadSkinL( majorId, minorId );

	return icon;

	}

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

// GetIconL

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

//

LOCAL_C CAknIcon* GetIconL( CMenuItem& aItem )

	{

	CAknIcon* icon = NULL;

    TUint iconId( 0 );

    TUint maskId( 0 );

	TPtrC attrStr( KNullDesC );

	TBool attrExists;

	TPtrC iconFilePath( aItem.GetAttributeL( KMenuAttrIconFile, attrExists ) );

	if ( !attrExists )

		{

		return NULL;

		}

	attrStr.Set( aItem.GetAttributeL( KMenuAttrIconId, attrExists ) );

	if ( attrExists )

		{

		User::LeaveIfError( MenuUtils::GetTUint( attrStr, iconId ) );

		}

	else

		{

		return NULL;

		}

	attrStr.Set( aItem.GetAttributeL( KMenuAttrMaskId, attrExists ) );

	if ( attrExists )

		{

		User::LeaveIfError( MenuUtils::GetTUint( attrStr, maskId ) );

		}

	else

		{

		return NULL;

		}

	CFbsBitmap* bitmap( 0 );

	CFbsBitmap* mask( 0 );

	RBuf pathBuf;

	pathBuf.CleanupClosePushL();

	ParseIconFilePathL(iconFilePath, pathBuf);

	AknIconUtils::CreateIconLC( bitmap, mask, pathBuf, iconId, maskId ); 

	icon = CAknIcon::NewL();

	icon->SetBitmap( bitmap );

	icon->SetMask( mask );

	CleanupStack::Pop( 2 );

    CleanupStack::PopAndDestroy( &pathBuf );

	return icon;

	}

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

// GetDefaultSkinL

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

//

LOCAL_C CAknIcon* GetDefaultSkinL( CMenuItem& aItem )

	{

	CAknIcon* icon = NULL;

    if ( KErrNone == aItem.Type().Compare( KMenuTypeApp ) )

        {

        TBool attrExists( EFalse );

        TPtrC appUidDes( aItem.GetAttributeL( KMenuAttrUid, attrExists ) );

        if( appUidDes == KMenuSatUiUid )

            {

            CMcsSatHandler* satHandler = CMcsSatHandler::NewL();

            CleanupStack::PushL( satHandler );

            icon = satHandler->LoadIconL();

            CleanupStack::PopAndDestroy( satHandler );

            }

        if( !icon )

            {

            if( aItem.GetAttributeL( KMenuAttrNative, attrExists ) == KMenuFalse )

            	{

				CFbsBitmap* bitmap( 0 );

				CFbsBitmap* mask( 0 );

				//for native

				if( CreateMbmIconLC2( bitmap, mask, appUidDes ) )

					{

					icon = CAknIcon::NewL();

					icon->SetBitmap( bitmap );

					icon->SetMask( mask );

					CleanupStack::Pop( 2 );

					}

            	}

            if( !icon )

                 {

                 TUint appUid;

                 TUid uid;

                 TInt err = MenuUtils::GetTUint( appUidDes, appUid );

                 if ( !err )

                     {

                     uid = TUid::Uid( appUid );

                     icon = LoadAppSkinL( uid );

                     }

                 }

           if( !icon )

                {

                icon = LoadSkinL(

                    KAknsIIDQgnMenuUnknownLst.iMajor,

                    KAknsIIDQgnMenuUnknownLst.iMinor );

                }

            }

        }

    else if ( KErrNone == aItem.Type().Compare( KMenuTypeFolder ) )

        {

        TUint childrenCount;

        TBool attrExists( EFalse );

        TInt err = MenuUtils::GetTUint( 

        	aItem.GetAttributeL( KChildrenCount, attrExists ), childrenCount );

        if( childrenCount > 0 )

            {

            icon = LoadSkinL(

                KAknsIIDQgnPropFolderAppsMedium.iMajor,

                KAknsIIDQgnPropFolderAppsMedium.iMinor ); 

            }

        else

            {

            icon = LoadSkinL(

                KAknsIIDQgnMenuFolderEmpty.iMajor,

                KAknsIIDQgnMenuFolderEmpty.iMinor );

            }

        }

    return icon;

	}

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

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

// MenuIconUtility::GetItemIconL

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

//

EXPORT_C CAknIcon* MenuIconUtility::GetItemIconL( CMenuItem& aItem )

	{

	CAknIcon* icon = NULL;

	// Try to get the skin of the item

	TRAP_IGNORE(icon = GetSkinL( aItem ));

	if ( icon )

		{

		return icon;

		}

	// Try to get the icon of the item (skin failed)

	TRAP_IGNORE(icon = GetIconL( aItem ));

	if ( icon )

		{

		return icon;

		}

	// Return a default (skin and icon failed)

	icon = GetDefaultSkinL( aItem );

	return icon;

	}