/*

* Copyright (c) 2002-2006 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:  All the files and folders icons are stored here

*

*/

// INCLUDE FILES

#include <FileManagerEngine.hrh>

#include <barsread.h>

#include <coemain.h>

#include <gulicon.h>

#include <AknsItemID.h>

#include <AknsUtils.h>

#include <FileManagerView.rsg>

#include "CFileManagerIconArray.h"

#include "FileManagerView.hrh"

// CONSTANTS

const TInt KGranularity = 1;

// needed because _LIT macro does not expand parameter, which is also macro

#define _CREATE_LIT( a, b ) _LIT( a, b )

_CREATE_LIT( KFileManagerMifFile, filemanager_mbm_file_location );

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

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

// CFileManagerIconArray::CFileManagerIconArray

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CFileManagerIconArray::CFileManagerIconArray() :

        CArrayPtrFlat( KGranularity )

    {

    }

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

// CFileManagerIconArray::NewL

// 

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

// 

EXPORT_C CFileManagerIconArray* CFileManagerIconArray::NewL()

    {

    CFileManagerIconArray* self = new (ELeave) CFileManagerIconArray();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CFileManagerIconArray::ConstructL

// 

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

// 

void CFileManagerIconArray::ConstructL()

    {

    TResourceReader reader;

    CCoeEnv::Static()->CreateResourceReaderLC(

        reader, R_FILEMANAGER_ICON_ARRAY );

    TInt count( reader.ReadInt16() );

    iIconInfo.ReserveL( count );

    SetReserveL( count );

    // Get File Manager mif drive from exe location

    TFileName exeFileName( RProcess().FileName() );

    // Load icon info now and actual icon data later when needed to decrease

    // construction time

    for( TInt i( 0 ); i < count; i++ )

        {

        TIconInfo info;

        info.iId = reader.ReadInt8();

        info.iFile = reader.ReadHBufCL();

        info.iIconId = reader.ReadInt16();

        TPtr ptr( info.iFile->Des() );

        if ( !ptr.CompareF( KFileManagerMifFile ) )

            {

            // Set correct File Manager mif drive

            ptr[ 0 ] = exeFileName[ 0 ];

            }

        info.iMaskId =  reader.ReadInt16();

        info.iMajorSkinId = reader.ReadInt32();

        info.iMinorSkinId = reader.ReadInt32();

        info.iIconType = reader.ReadInt8();

        info.iIndex = KErrNotFound;

        CleanupStack::PushL( info.iFile );

        iIconInfo.AppendL( info );

        CleanupStack::Pop( info.iFile );

        }

    CleanupStack::PopAndDestroy(); // reader

    LoadMandatoryIconsL();

    }

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

// CFileManagerIconArray::~CFileManagerIconArray

// Destructor

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

// 

EXPORT_C CFileManagerIconArray::~CFileManagerIconArray()

    {

    TInt count( iIconInfo.Count() );

    for( TInt i( 0 ); i < count; i++ )

        {

        TIconInfo& info = iIconInfo[ i ];

        delete info.iFile;

        info.iFile = NULL;

        }

    iIconInfo.Close();

    }

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

// CFileManagerIconArray::UpdateIconsL

//

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

// 

EXPORT_C void CFileManagerIconArray::UpdateIconsL()

    {

    // Remove icon data and set info to load icon data again when needed

    ResetAndDestroy();

    TInt count( iIconInfo.Count() );

    SetReserveL( count );

    for( TInt i( 0 ); i < count; i++ )

        {

        TIconInfo& info = iIconInfo[ i ];

        info.iIndex = KErrNotFound;

        }

    LoadMandatoryIconsL();

    }

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

// CFileManagerIconArray::FindIcon

//

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

// 

EXPORT_C TInt CFileManagerIconArray::FindIcon( TInt aIconId )

    {

    TInt count( iIconInfo.Count() );

    for( TInt i( 0 ); i < count; i++ )

        {

        TIconInfo& info = iIconInfo[ i ];

        if ( info.iId == aIconId )

            {

            if ( info.iIndex == KErrNotFound )

                {

                TRAPD( err, LoadIconL( info ) );

                if ( err != KErrNone )

                    {

                    return err;

                    }

                }

            return info.iIndex;

            }

        }

    return KErrNotFound;

    }

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

// CFileManagerIconArray::LoadIconL

//

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

// 

void CFileManagerIconArray::LoadIconL( TIconInfo& aInfo )

    {

    CGulIcon* icon = LoadIconL(

        *aInfo.iFile,

        aInfo.iIconId,

        aInfo.iMaskId,

        aInfo.iMajorSkinId,

        aInfo.iMinorSkinId,

        aInfo.iIconType == EFileManagerIconColorIcon );

    CleanupStack::PushL( icon );

    TInt index( Count() );

    AppendL( icon );

    CleanupStack::Pop( icon );

    aInfo.iIndex = index;

    }

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

// CFileManagerIconArray::LoadMandatoryIconsL

// 

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

// 

void CFileManagerIconArray::LoadMandatoryIconsL()

    {

    // At least these icons must be loaded on startup.

    // Other icons can be loaded first time when needed.

    // Make sure that selection icon is always loaded to first index.

    // Required by list control.

    User::LeaveIfError( FindIcon( EFileManagerMarkIcon ) );

    }

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

// CFileManagerIconArray::LoadIconL

//

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

// 

EXPORT_C CGulIcon* CFileManagerIconArray::LoadIconL(

        const TDesC& aIconFile,

        TInt aIconId,

        TInt aMaskId,

        TInt aMajorSkin,

        TInt aMinorSkin,

        TBool aIsColorIcon )

    {

    TAknsItemID aknsItemId;

    aknsItemId.Set( aMajorSkin, aMinorSkin );

    MAknsSkinInstance* aknsSkin = AknsUtils::SkinInstance();

    CGulIcon* ret = NULL;

    if ( aIsColorIcon )

        {

        TRgb defaultColour( KRgbBlack );

        CFbsBitmap* bmap = NULL;

        CFbsBitmap* mask = NULL;

        AknsUtils::GetCachedColor(

            aknsSkin,

            defaultColour,

            KAknsIIDQsnIconColors,

            EAknsCIQsnIconColorsCG13 );

        AknsUtils::CreateColorIconLC(

            aknsSkin,

            aknsItemId,

            KAknsIIDQsnIconColors,

            EAknsCIQsnIconColorsCG13,

            bmap,

            mask,

            aIconFile,

            aIconId,

            aMaskId,

            defaultColour );

        ret = CGulIcon::NewL( bmap, mask );

        ret->SetBitmapsOwnedExternally( EFalse );

        CleanupStack::Pop( 2 ); // icon owns the bitmaps now

        }

    else

        {

        ret = AknsUtils::CreateGulIconL(

            aknsSkin, aknsItemId, aIconFile, aIconId, aMaskId );

        ret->SetBitmapsOwnedExternally( EFalse );

        }

    return ret;

    }

//  End of File