/*
* Copyright (c) 2002 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:    LandmarksUi Content File -
*
*/








// INCLUDE FILES
#include "CLmkSelectorIconMgr.h"
#include "LmkConsts.h"
#include "CLmkUiUtils.h"
#include <data_caging_path_literals.hrh>
#include <gulicon.h>
#include <AknIconArray.h>
#include <avkon.mbg>
#include <AknsConstants.h>
#include <AknsUtils.h>
#include <AknIconUtils.h>
#include <AknUtils.h>
#include <lmkerrors.h>


// CONSTANTS
/// Unnamed namespace for local definitions
namespace {
const TInt KLmkIconCacheGranularity = 30;
const TInt KLmkIconFilesGranularity = 5;
#if defined(_DEBUG)

_LIT(KPanicMsg,"CLmkSelectorIconMgr");

void Panic( TPanicCode aReason )
    {
    User::Panic( KPanicMsg, aReason );
    }
#endif
}  // namespace

// ----------------------------------------------------
// CLmkSelectorIconMgr::TIconData
// ----------------------------------------------------
//
CLmkSelectorIconMgr::TIconData::TIconData():
    iFileIndex( KErrNotFound ),
    iIconIndexWithinFile( KErrNotFound ),
    iIconType( EDefinedIcon ),
    iIconArrayId( KErrNotFound )
    {
    }

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

// -----------------------------------------------------------------------------
// CLmkSelectorIconMgr::CLmkSelectorIconMgr
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CLmkSelectorIconMgr::CLmkSelectorIconMgr( CAknIconArray& aArray )
    : iArray( &aArray ),
      iCache( KLmkIconCacheGranularity )
    {
    }

// -----------------------------------------------------------------------------
// CLmkSelectorIconMgr::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CLmkSelectorIconMgr::ConstructL()
    {
    iIconFiles = new( ELeave ) CDesCArrayFlat( KLmkIconFilesGranularity );
    ResetMgrL();
    }

// -----------------------------------------------------------------------------
// CLmkSelectorIconMgr::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//

CLmkSelectorIconMgr* CLmkSelectorIconMgr::NewL(
    CAknIconArray& aArray )
    {
    CLmkSelectorIconMgr* self = new( ELeave ) CLmkSelectorIconMgr( aArray );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::~CLmkSelectorIconMgr
// ----------------------------------------------------
//
CLmkSelectorIconMgr::~CLmkSelectorIconMgr()
    {
    iCache.Close();
    delete iIconFiles;
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::GetIconL
// ----------------------------------------------------
//
TInt CLmkSelectorIconMgr::GetIconL(
    const TDesC& aMbmFileName,
    TInt aIconIdInFile )
    {
    TInt position( 0 );
    if ( iIconFiles->Find( aMbmFileName, position, ECmpNormal ) == 0 )
        { // same file has been used already and so it exists in the array
        TInt count = iCache.Count();
        for ( TInt i( 0 ); i < count; ++i )
            {
            if ( position == iCache[i].iFileIndex  &&
                aIconIdInFile == iCache[i].iIconIndexWithinFile )
                { // icon was found in icon manager!
                // If Array Index was not set properly, then set the index propely
                if (( iCache[i].iIconArrayId < 0) ||
                	  (iCache[i].iIconArrayId > KLmkIconCacheGranularity) )
	                {
	                break;
	                }
                return iCache[i].iIconArrayId;
                }
            }
        }

    // aMbmFileName does not yet exist in the file name array OR it exists but
    // this specific icon hasn't been requested yet:

    // create icon manager item:
    TInt iconMgrId = CreateIconMgrItemL( aMbmFileName, aIconIdInFile );

    // try to load new icon:
    iCache[iconMgrId].iIconArrayId =
        LoadAndAppendIconL( aMbmFileName, aIconIdInFile );

    return iCache[iconMgrId].iIconArrayId;
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::GetDefaultIconL
// ----------------------------------------------------
//
TInt CLmkSelectorIconMgr::GetDefaultIconL( TIconType aIcon )
    {
    TInt count = iCache.Count();
    for ( TInt i( 0  ); i < count ; ++i )
        {
        TIconData tmp = iCache[i];
        if ( tmp.iIconType == aIcon )
            { // default icon was found
            if ( tmp.iIconArrayId < 0 )
                { // try to load new icon.
                TPtrC iconFile = ( *iIconFiles )[tmp.iFileIndex];
                tmp.iIconArrayId =
                    LoadAndAppendIconL( iconFile, tmp.iIconIndexWithinFile );
                }
            return tmp.iIconArrayId;
            }
        }
    return KErrNotFound; // default icon was not found
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::SetDefaultIconL
// ----------------------------------------------------
//
void CLmkSelectorIconMgr::SetDefaultIconL(
    TIconType aIcon,
    const TDesC& aMbmFileName,
    TInt aIconIdInFile )
    {
    if ( GetDefaultIconL( aIcon ) >= 0 )
        { // default icon already set
        User::Leave( KErrAlreadyExists );
        }

    TInt iconMgrId = CreateIconMgrItemL( aMbmFileName, aIconIdInFile );
    iCache[iconMgrId].iIconType = aIcon;
    // Added for updating Icon index
    iCache[iconMgrId].iIconArrayId =
        LoadAndAppendIconL( aMbmFileName, aIconIdInFile );
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::SetIconAtIndexZeroL
// ----------------------------------------------------
//
void CLmkSelectorIconMgr::SetIconAtIndexZeroL(
    const TDesC& aMbmFileName,
    TAknsItemID aSkinID,
    TInt aIconId,
    TInt aMaskId )
    {
    __ASSERT_DEBUG( iArray->Count() >= 2,
                    Panic( KLmkPanicIndexesZeroOneNotSet ) );

    CGulIcon* icon = LoadIconL( aMbmFileName, aSkinID, aIconId, aMaskId );
    CleanupStack::PushL( icon );

    CGulIcon* old = iArray->At( 0 );
    iArray->Delete( 0 );
    delete old;
    iArray->InsertL( 0, icon );

    CleanupStack::Pop( icon ); // ownership transferred to icon array
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::SetIconAtIndexOneL
// ----------------------------------------------------
//
void CLmkSelectorIconMgr::SetIconAtIndexOneL(
    const TDesC& aMbmFileName,
    TAknsItemID aSkinID,
    TInt aIconId,
    TInt aMaskId )
    {
    __ASSERT_DEBUG( iArray->Count() >= 2,
                    Panic( KLmkPanicIndexesZeroOneNotSet ) );

    CGulIcon* icon = LoadIconL( aMbmFileName, aSkinID, aIconId, aMaskId );
    CleanupStack::PushL( icon );

    CGulIcon* old = iArray->At( 1 );
    iArray->Delete( 1 );
    delete old;
    iArray->InsertL( 1, icon );

    CleanupStack::Pop( icon ); // ownership transferred to icon array
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::ResetMgrL
// ----------------------------------------------------
//
void CLmkSelectorIconMgr::ResetMgrL()
    {
    iArray->ResetAndDestroy();
    iIconFiles->Reset();
    iCache.Reset();

    // By default set empty icons as selection icons:

    TFileName* iconFile = CLmkUiUtils::AvkonIconFileLC();
    CGulIcon* icon = LoadIconL( *iconFile,
                                KAknsIIDQgnPropEmpty,
                                EMbmAvkonQgn_prop_empty,
                                EMbmAvkonQgn_prop_empty_mask );
    CleanupStack::PushL( icon );
    iArray->AppendL( icon );
    CleanupStack::Pop( icon ); // ownership transferred to icon array
    icon = NULL;

    icon = LoadIconL( *iconFile,
                      KAknsIIDQgnPropEmpty,
                      EMbmAvkonQgn_prop_empty,
                      EMbmAvkonQgn_prop_empty_mask );
    CleanupStack::PushL( icon );
    iArray->AppendL( icon );
    CleanupStack::Pop( icon ); // ownership transferred to icon array
    CleanupStack::PopAndDestroy( ); // iconFile
    }

// ============================= HELPER METHODS ================================

// ----------------------------------------------------
// CLmkSelectorIconMgr::LoadIconL
// ----------------------------------------------------
//
CGulIcon* CLmkSelectorIconMgr::LoadIconL(
    const TDesC& aMbmFileName,
    TInt aIconIdInFile )
    {
    CFbsBitmap* bitmap = NULL;
    CFbsBitmap* bitmapMask = NULL;

	AknIconUtils::CreateIconLC(bitmap, bitmapMask, aMbmFileName,
                             aIconIdInFile, aIconIdInFile + 1);
    CGulIcon* icon = CGulIcon::NewL( bitmap, bitmapMask );
    CleanupStack::Pop( 2 ); // bitmapMask, bitmap. icon has now ownership
    return icon;
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::LoadIconL
// ----------------------------------------------------
//
CGulIcon* CLmkSelectorIconMgr::LoadIconL(
    const TDesC& aMbmFileName,
    TAknsItemID aSkinID,
    TInt aIconId,
    TInt aMaskId )
    {
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    CFbsBitmap* bitmap = NULL;
    CFbsBitmap* bitmapMask = NULL;
    AknsUtils::CreateIconLC( skin, aSkinID, bitmap, bitmapMask, aMbmFileName,
                             aIconId, aMaskId );
    CGulIcon* icon = CGulIcon::NewL( bitmap, bitmapMask );
    CleanupStack::Pop( 2 ); // bitmapMask, bitmap. icon has now ownership
    return icon;
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::LoadAndAppendIconL
// ----------------------------------------------------
//
TInt CLmkSelectorIconMgr::LoadAndAppendIconL(
    const TDesC& aMbmFileName,
    TInt aIconIdInFile )
    {
    CGulIcon* icon = LoadIconL( aMbmFileName, aIconIdInFile );
    CleanupStack::PushL( icon );
    iArray->AppendL( icon );
    CleanupStack::Pop( icon );
    // Added for avoiding returning -1 as bitmap Index
    if (iArray->Count() > 0)
	    {
	    return iArray->Count() - 1;
	    }
    else
	    {
	    return 0;
	    }
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::CreateIconMgrItemL
// ----------------------------------------------------
//
TInt CLmkSelectorIconMgr::CreateIconMgrItemL(
    const TDesC& aMbmFileName,
    TInt aIconIdInFile )
    {
    TIconData tmp;


    tmp.iFileIndex = AppendedIconFileIndexL( aMbmFileName );
    tmp.iIconIndexWithinFile = aIconIdInFile;

    User::LeaveIfError( iCache.Append( tmp ) );
    if (iCache.Count() > 0)
	    {
	    return iCache.Count() - 1;
	    }
    else
	    {
	    return 0;
	    }
    }

// ----------------------------------------------------
// CLmkSelectorIconMgr::AppendedIconFileIndexL
// ----------------------------------------------------
//
TInt CLmkSelectorIconMgr::AppendedIconFileIndexL( const TDesC& aMbmFileName )
    {
    TInt position( 0 );
    if ( iIconFiles->Find( aMbmFileName, position, ECmpNormal ) != 0 )
        { // file does not yet exist in the file name array
        iIconFiles->AppendL( aMbmFileName );
        return iIconFiles->Count() - 1;
        }
    else
        { // file already exists, just return its position
        return position;
        }
    }

//  End of File