/*
* 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:
*
*/
// 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 <liwcommon.h>
//#include "mcsextendedmenuitem.h"
#include "mcsiconutility.h"
#include "mcssathandler.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();
// The line below was commented out to improve the appearance of scaled
// icons of java applications.
// 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( const CLiwDefaultMap* aMap )
{
CAknIcon* icon = NULL;
TUint majorId( 0 );
TUint minorId( 0 );
TPtrC idString( KNullDesC );
TLiwVariant variant;
variant.PushL();
TBuf8<KMenuMaxAttrNameLen> attrName;
attrName.Copy( KMenuAttrIconSkinMajorId );
if( aMap->FindL( attrName, variant))
{
variant.Get( idString );
User::LeaveIfError( MenuUtils::GetTUint( idString, majorId ) );
attrName.Copy( KMenuAttrIconSkinMinorId );
if( aMap->FindL( attrName, variant))
{
variant.Get( idString );
User::LeaveIfError( MenuUtils::GetTUint( idString, minorId ) );
icon = LoadSkinL( majorId, minorId );
}
}
CleanupStack::PopAndDestroy( &variant );
return icon;
}
// ---------------------------------------------------------
// GetIconL
// ---------------------------------------------------------
//
LOCAL_C CAknIcon* GetIconL( const CLiwDefaultMap* aMap )
{
CAknIcon* icon = NULL;
TUint iconId( 0 );
TUint maskId( 0 );
TPtrC attrStr( KNullDesC );
TPtrC iconFilePath;
TLiwVariant variantIconFile;
TLiwVariant variantIconId;
TLiwVariant variantMaskId;
variantIconFile.PushL();
variantIconId.PushL();
variantMaskId.PushL();
TBuf8<KMenuMaxAttrNameLen> attrName;
attrName.Copy( KMenuAttrIconFile );
if( aMap->FindL( attrName, variantIconFile))
{
variantIconFile.Get( iconFilePath );
attrName.Copy( KMenuAttrIconId );
if( aMap->FindL( attrName, variantIconId) )
{
variantIconId.Get( attrStr );
User::LeaveIfError( MenuUtils::GetTUint( attrStr, iconId ) );
attrName.Copy( KMenuAttrMaskId );
if( aMap->FindL( attrName, variantMaskId) )
{
variantMaskId.Get( attrStr );
User::LeaveIfError( MenuUtils::GetTUint( attrStr, maskId ) );
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 );
}
}
}
CleanupStack::PopAndDestroy( &variantMaskId );
CleanupStack::PopAndDestroy( &variantIconId );
CleanupStack::PopAndDestroy( &variantIconFile );
return icon;
}
// ---------------------------------------------------------
// GetDefaultSkinL
// ---------------------------------------------------------
//
LOCAL_C CAknIcon* GetDefaultSkinL( const CLiwDefaultMap* aMap )
{
CAknIcon* icon = NULL;
TPtrC attrValueUid(KNullDesC);
TPtrC attrValueNative(KNullDesC);
TPtrC attrValueChildren(KNullDesC);
TLiwVariant variantUid;
variantUid.PushL();
TLiwVariant variantNative;
variantNative.PushL();
TLiwVariant variantChildren;
variantChildren.PushL();
TBuf8<KMenuMaxAttrNameLen> attrName;
//APPLICATION
attrName.Copy( KMenuAttrUid );
if( aMap->FindL( attrName, variantUid))
{
variantUid.Get( attrValueUid );
if( attrValueUid == KMenuSatUiUid )
{
CMcsSatHandler* satHandler = CMcsSatHandler::NewL();
CleanupStack::PushL( satHandler );
icon = satHandler->LoadIconL();
CleanupStack::PopAndDestroy( satHandler );
}
if( !icon )
{
attrName.Copy( KMenuAttrNative );
if( aMap->FindL( attrName, variantNative) )
{
variantNative.Get( attrValueNative );
if( attrValueNative == KMenuFalse )
{
CFbsBitmap* bitmap( 0 );
CFbsBitmap* mask( 0 );
//for native
if( CreateMbmIconLC2( bitmap, mask, attrValueUid ) )
{
icon = CAknIcon::NewL();
icon->SetBitmap( bitmap );
icon->SetMask( mask );
CleanupStack::Pop( 2 );
}
}
}
if( !icon )
{
TUint appUid;
TUid uid;
TInt err = MenuUtils::GetTUint( attrValueUid, appUid );
if ( !err )
{
uid = TUid::Uid( appUid );
icon = LoadAppSkinL( uid );
}
}
if( !icon )
{
icon = LoadSkinL(
KAknsIIDQgnMenuUnknownLst.iMajor,
KAknsIIDQgnMenuUnknownLst.iMinor );
}
}
}
//FOLDER
TUint childrenCount;
attrName.Copy( KChildrenCount );
if( aMap->FindL( attrName, variantChildren))
{
variantChildren.Get( attrValueChildren );
TInt err = MenuUtils::GetTUint( attrValueChildren, childrenCount );
if( childrenCount > 0 )
{
icon = LoadSkinL(
KAknsIIDQgnPropFolderAppsMedium.iMajor,
KAknsIIDQgnPropFolderAppsMedium.iMinor );
}
else
{
icon = LoadSkinL(
KAknsIIDQgnMenuFolderEmpty.iMajor,
KAknsIIDQgnMenuFolderEmpty.iMinor );
}
}
CleanupStack::PopAndDestroy( &variantChildren );
CleanupStack::PopAndDestroy( &variantNative );
CleanupStack::PopAndDestroy( &variantUid );
return icon;
}
// ================= MEMBER FUNCTIONS =======================
// ---------------------------------------------------------
// MenuIconUtility::GetItemIconL
// ---------------------------------------------------------
//
CAknIcon* McsIconUtility::GetItemIconL( const CLiwDefaultMap* aMap )
{
CAknIcon* icon = NULL;
// Try to get the skin of the item
TRAP_IGNORE(icon = GetSkinL( aMap ));
if ( icon )
{
return icon;
}
// Try to get the icon of the item (skin failed)
TRAP_IGNORE(icon = GetIconL( aMap ));
if ( icon )
{
return icon;
}
// Return a default (skin and icon failed)
icon = GetDefaultSkinL( aMap );
return icon;
}