/*
* 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;
}