/*

* Copyright (c) 2005-2007 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:  Phonebook 2 icon factory.

*

*/

#include <CPbk2IconFactory.h>

// Phonebook2

#include "CPbk2IconInfo.h"

#include <RPbk2LocalizedResourceFile.h>

#include <Pbk2DataCaging.hrh>

#include <Pbk2CommonUi.rsg>

#include <CPbk2IconInfoContainer.h>

// System includes

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsUtils.h>

#include <aknenv.h>

#include <barsread.h>

#include <gulicon.h>

#include <CPbk2ServiceManager.h> 

#include <MPbk2ApplicationServices.h>

#include <CPbk2ApplicationServices.h>

// Debugging headers

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

_LIT( KPbk2CommonUiResFile, "Pbk2CommonUi.rsc" );

/**

 * Creates a bitmap from given icon info using Avkon services.

 *

 * @param aSkin         Skin instance.

 * @param aBitmap       Created bitmap.

 * @param aMask         Created mask.

 * @param aIconInfo     Icon information.

 */

void CreateBitmapsLC(

        MAknsSkinInstance* aSkin,

        CFbsBitmap*& aBitmap,

        CFbsBitmap*& aMask,

        const CPbk2IconInfo& aIconInfo )

    {

    //Instantiate external bitmaps. We use rather graceful approach because we're

    //handling external bitmaps. So if problems we don't leave and paralyse system

    //but just try to continue if possible.

    if (aIconInfo.IsIconExternal() )

        {

        //Check external bitmaps really exist

        if(!aIconInfo.ExternalBitmap() || !aIconInfo.ExternalMask())

            {

            User::Leave(KErrBadHandle);

            }

        //Calculate size for external icon

        TSize size = aIconInfo.ExternalIconSize();

        //Try to instantiate ext bitmaps if not yet done, otherwise duplicating fails

        if(!aIconInfo.ExternalBitmap()->Handle())

            {

            CFbsBitmap* tmp = const_cast<CFbsBitmap*>(aIconInfo.ExternalBitmap());

            AknIconUtils::SetSize( tmp, size );

            tmp = const_cast<CFbsBitmap*>(aIconInfo.ExternalMask());

            AknIconUtils::SetSize( tmp, size );

            }

        //Create bitmaps and try to duplicate their handles to point to external bitmaps

        aBitmap = new( ELeave ) CFbsBitmap();

        CleanupStack::PushL( aBitmap );

        aMask = new( ELeave ) CFbsBitmap();

        CleanupStack::PushL( aMask );

        aBitmap->Duplicate( aIconInfo.ExternalBitmap()->Handle() );

        aMask->Duplicate( aIconInfo.ExternalMask()->Handle() );

        //Try always to set size as ext icon may have been used by some other app too.

        AknIconUtils::SetSize( aBitmap, size );

        AknIconUtils::SetSize( aMask, size );

        return;

        }

    if ( aIconInfo.ColorId() == KAknsIIDNone )

        {

        AknsUtils::CreateIconLC(

             aSkin, aIconInfo.SkinId(), aBitmap, aMask,

             aIconInfo.MbmFileName(),

             aIconInfo.IconId(), aIconInfo.MaskId() );

        }

    else

        {

        AknsUtils::CreateColorIconLC(

             aSkin, aIconInfo.SkinId(),

             aIconInfo.ColorId(), aIconInfo.ColorIndex(),

             aBitmap, aMask,

             aIconInfo.MbmFileName(),

             aIconInfo.IconId(), aIconInfo.MaskId(),

             AKN_LAF_COLOR_STATIC( aIconInfo.DefaultColorIndex() ) );

        }

    }

/**

 * Creates a bitmap from given icon info using Avkon services.

 *

 * @param aSkin         Skin instance.

 * @param aBitmap       Created bitmap.

 * @param aMask         Created mask.

 * @param aIconInfo     Icon information.

 */

void CreateBitmapsL(

        MAknsSkinInstance* aSkin,

        CFbsBitmap*& aBitmap,

        CFbsBitmap*& aMask,

        const CPbk2IconInfo& aIconInfo )

    {

    CreateBitmapsLC( aSkin, aBitmap, aMask, aIconInfo );

    CleanupStack::Pop( 2 ); // bitmap, mask

    }

} /// namespace

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

// CPbk2IconFactory::CPbk2IconFactory

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

//

CPbk2IconFactory::CPbk2IconFactory(

        const CPbk2IconInfoContainer* aIconContainer ) :

            iIconContainer( aIconContainer )

    {

    }

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

// CPbk2IconFactory::~CPbk2IconFactory

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

//

CPbk2IconFactory::~CPbk2IconFactory()

    {

    delete iAllIconsContainer;

    Release( iAppServices );

    }

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

// CPbk2IconFactory::NewLC

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

//

EXPORT_C CPbk2IconFactory* CPbk2IconFactory::NewL()

    {

    CPbk2IconFactory* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2IconFactory::NewLC

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

//

EXPORT_C CPbk2IconFactory* CPbk2IconFactory::NewLC()

    {

    CPbk2IconFactory* self = new( ELeave ) CPbk2IconFactory( NULL );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CPbk2IconFactory::NewL

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

//

EXPORT_C CPbk2IconFactory* CPbk2IconFactory::NewL(

        const CPbk2IconInfoContainer& aIconContainer )

    {

    CPbk2IconFactory* self = NewLC( aIconContainer );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2IconFactory::NewLC

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

//

EXPORT_C CPbk2IconFactory* CPbk2IconFactory::NewLC(

        const CPbk2IconInfoContainer& aIconContainer )

    {

    CPbk2IconFactory* self = new( ELeave )

        CPbk2IconFactory( &aIconContainer );

    CleanupStack::PushL( self );

    return self;

    }

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

// CPbk2IconFactory::ConstructL

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

//

void CPbk2IconFactory::ConstructL()

    {

    CCoeEnv& coeEnv = *CCoeEnv::Static();

    RPbk2LocalizedResourceFile resFile( coeEnv );

    resFile.OpenLC( KPbk2RomFileDrive,

                   KDC_RESOURCE_FILES_DIR, KPbk2CommonUiResFile );

    TResourceReader reader;

    coeEnv.CreateResourceReaderLC( reader, R_PBK2_ICON_INFO_ARRAY );

    iAllIconsContainer = CPbk2IconInfoContainer::NewL( reader );

    //Calculate preferred size for xsp service icons 

    TRect mainPane;

    AknLayoutUtils::LayoutMetricsRect(

        AknLayoutUtils::EMainPane, mainPane );

    TAknLayoutRect listLayoutRect;

    listLayoutRect.LayoutRect(

        mainPane,

        AknLayoutScalable_Avkon::list_single_graphic_pane_g1(0).LayoutLine() );

    TSize size(listLayoutRect.Rect().Size());

    // Add xsp service icons2

    if ( !iAppServices )

    	{

    	iAppServices = CPbk2ApplicationServices::InstanceL();

    	}

    CPbk2ServiceManager& servMan( iAppServices->ServiceManager()); 

    const CPbk2ServiceManager::RServicesArray& services = servMan.Services();

    TUid uid;

    uid.iUid = KPbk2ServManId;

    for ( TInt i = 0; i < services.Count(); i++ )

        {

        const CPbk2ServiceManager::TService& service = services[i];

        if ( service.iBitmapId && service.iBitmap )

            {

            TPbk2IconId id = TPbk2IconId( uid, services[i].iBitmapId );

            CPbk2IconInfo* info = CPbk2IconInfo::NewLC(

                id, services[i].iBitmap, services[i].iMask, size );

            iAllIconsContainer->AppendIconL(info);

            CleanupStack::Pop(info);

            }

        }    

    CleanupStack::PopAndDestroy( 2 ); // resFile, reader

    iIconContainer = iAllIconsContainer;

    }

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

// CPbk2IconFactory::CreateIconL

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

//

EXPORT_C CGulIcon* CPbk2IconFactory::CreateIconL(

        const TPbk2IconId& aIconId ) const

    {

    CGulIcon* icon = CreateIconLC( aIconId );

    if ( icon )

        {

        CleanupStack::Pop( icon );

        }

    return icon;

    }

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

// CPbk2IconFactory::CreateIconLC

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

//

EXPORT_C CGulIcon* CPbk2IconFactory::CreateIconLC(

        const TPbk2IconId& aIconId ) const

    {

    CGulIcon* icon = CGulIcon::NewLC();

    const CPbk2IconInfo* iconInfo = iIconContainer->Find( aIconId );

    if ( !iconInfo )

        {

        return icon;

        }

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2IconInfoContainer::LoadBitmapL icon found"));

    icon->SetBitmapsOwnedExternally(EFalse);

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2IconInfoContainer::LoadBitmapL about to create icon"));

    CreateBitmapsL( AknsUtils::SkinInstance(),

        bitmap, mask, *iconInfo );

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ( "CPbk2IconInfoContainer::LoadBitmapL icon create done" ) );

    icon->SetBitmap(bitmap);

    icon->SetMask(mask);

    return icon;

    }

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

// CPbk2IconFactory::CreateIconL

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

//

EXPORT_C void CPbk2IconFactory::CreateIconL( const TPbk2IconId& aIconId,

        MAknsSkinInstance& aSkin, CFbsBitmap*& aBitmap, CFbsBitmap*& aMask )

    {

    CreateIconLC( aIconId, aSkin, aBitmap, aMask );

    CleanupStack::Pop( 2 ); // aBitmap, aMask

    }

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

// CPbk2IconFactory::CreateIconLC

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

//

EXPORT_C void CPbk2IconFactory::CreateIconLC( const TPbk2IconId& aIconId,

        MAknsSkinInstance& aSkin, CFbsBitmap*& aBitmap, CFbsBitmap*& aMask )

    {

    const CPbk2IconInfo* iconInfo = iIconContainer->Find( aIconId );

    if ( iconInfo )

        {

        CreateBitmapsLC( &aSkin, aBitmap, aMask, *iconInfo );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CPbk2IconFactory::CreateImageL

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

//

EXPORT_C CEikImage* CPbk2IconFactory::CreateImageL(

        const TPbk2IconId& aIconId ) const

    {

    CEikImage* image = CreateImageLC( aIconId );

    if ( image )

        {

        CleanupStack::Pop( image );

        }

    return image;

    }

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

// CPbk2IconFactory::CreateImageLC

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

//

EXPORT_C CEikImage* CPbk2IconFactory::CreateImageLC(

        const TPbk2IconId& aIconId ) const

    {

    CEikImage* image = NULL;

    const CPbk2IconInfo* iconInfo = iIconContainer->Find( aIconId );

    if ( iconInfo )

        {

        image = new(ELeave) CEikImage;

        CleanupStack::PushL( image );

        CFbsBitmap* bitmap = NULL;

        CFbsBitmap* mask = NULL;

        CreateBitmapsL( AknsUtils::SkinInstance(),

            bitmap, mask, *iconInfo );

        image->SetBitmap( bitmap );

        image->SetMask( mask );

        }

    return image;

    }

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

// CPbk2IconFactory::AppendIconL

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

//

EXPORT_C void CPbk2IconFactory::AppendIconL(

        CPbk2IconInfo* aIconInfo )

    {

    if( !iAllIconsContainer )

        {

        ConstructL();

        }

    iAllIconsContainer->AppendIconL(aIconInfo);

    iIconContainer = iAllIconsContainer;

    }

// End of File