/*

* Copyright (c) 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:  

*     Handles different mce bitmaps.

*     First collects all the bitmaps from different mtm's and also local

*     folder's bitmaps to icon array.

*

*/

// INCLUDE FILES

#include "MceOneRowMessageListBitmapResolver.h"

#include <mtudcbas.h>       // cbasemtmuidata

#include "MtmRegistryObserver.h" // mmtmuidataregistryobserver

#include <msvuids.h>

#include <msvids.h>         // fixed entry ids

#include <gulicon.h>        // CGulIcon

#include <AknIconArray.h>   // cakniconarray

#include <fbs.h>            // CFbsFont

#include <muiu.mbg>         // bitmap enums

#include <avkon.mbg>        // bitmap enums

#include <mtud.hrh>         // EMtudEntryStateOpen

#include <SenduiMtmUids.h>  // mtm uids

#include <aknsinglecolumnstyletreelist.h>

#include "MceUtils.h"

// security data caging

#include <data_caging_path_literals.hrh>

#include <bldvariant.hrh>

#include <AknIconUtils.h>

// LOCAL CONSTANTS AND MACROS

_LIT( KMceDirAndFileMuiu,"muiu.mbm" );

const TInt KMceIconArrayGranularity = 10;

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

CMceOneRowBitmapResolver* CMceOneRowBitmapResolver::NewL(

    CMsvSessionPtr aSession,

    MMtmUiDataRegistryObserver& aRegObserver )

    { // static

    CMceOneRowBitmapResolver* self=new(ELeave) CMceOneRowBitmapResolver(

        aSession,

        aRegObserver );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    return self;

    }

CMceOneRowBitmapResolver::CMceOneRowBitmapResolver(

    CMsvSessionPtr aSession,

    MMtmUiDataRegistryObserver& aRegObserver )

    :

    iRegObserver( aRegObserver ),

    iSession( aSession ),

    iBitmapsLoaded( 0 )

    {

    }

CMceOneRowBitmapResolver::~CMceOneRowBitmapResolver()

    {

    if ( iIcons )

        {

        iIcons->ResetAndDestroy();

        }

    delete iIcons;

    iIconArray.Close();

    }

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

// CMceOneRowBitmapResolver::ConstructL

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

void CMceOneRowBitmapResolver::ConstructL()

    {

    // security data caging

    TParse fp;

    fp.Set( AknIconUtils::AvkonIconFileName(), &KDC_RESOURCE_FILES_DIR , NULL );

    iFilenameAvkon = fp.FullName();

    fp.Set( KMceDirAndFileMuiu, &KDC_APP_BITMAP_DIR , NULL );

    iFilenameMuiu = fp.FullName();

    iIcons = new(ELeave) CAknIconArray( KMceIconArrayGranularity );

    ChangeBitmapInIconArrayL();

    iIconArray.Reset();

    for ( TInt i = EMceBitmapIndexUnknown; i < EMceBitmapIndexLastIconIndex; i++ )

        {

        TMceHierListIconEntry iconEntry;

        iconEntry.iBitmapPointer = 0;

        iconEntry.iIconId = 0;

        iIconArray.AppendL( iconEntry );

        }

    }

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

// CMceOneRowBitmapResolver::CreateAndAppendIconL

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

void CMceOneRowBitmapResolver::CreateAndAppendIconL(

    MAknsSkinInstance* aSkin,

    TAknsItemID aId,

    const TDesC& aFileName,

    TInt aBitmapIndex, 

    TMceOneRowBitmapLoadType aBitmapType )

    {

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    if ( aBitmapType == EMceOneRowBitmapLoadNormal )

        {

        AknsUtils::CreateIconL( 

            aSkin, 

            aId, 

            bitmap,

            mask, 

            aFileName, 

            aBitmapIndex, 

            aBitmapIndex + 1 );  

        }

    else if ( aBitmapType == EMceOneRowBitmapLoadSkinned )

        {

        AknsUtils::CreateColorIconL(

            aSkin,

            aId,

            KAknsIIDQsnIconColors,

            EAknsCIQsnIconColorsCG13,

            bitmap,

            mask,

            aFileName,

            aBitmapIndex,

            aBitmapIndex + 1,

            KRgbBlack );

        }

    else

        {

        AknsUtils::CreateColorIconL(

            aSkin,

            aId,

            KAknsIIDQsnIconColors,

            EAknsCIQsnIconColorsCG16,

            bitmap,

            mask,

            aFileName,

            aBitmapIndex,

            aBitmapIndex + 1,

            KRgbBlack );

        }

    CGulIcon* icon = CGulIcon::NewL( bitmap, mask );

    CleanupStack::PushL( icon );

    iIcons->AppendL( icon );

    CleanupStack::Pop(); // icon

    iBitmapsLoaded = iIcons->Count();

    }

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

// CMceOneRowBitmapResolver::IconArray

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

CArrayPtrFlat<CGulIcon>* CMceOneRowBitmapResolver::IconArray()

    {

    return iIcons;

    }

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

// CMceOneRowBitmapResolver::BitmapIndex

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

TInt CMceOneRowBitmapResolver::BitmapIndex( const TMsvEntry& aEntry )

    {

    TInt foundIndex = KErrNotFound;

    const TMsvId id = aEntry.Id();

    if ( aEntry.iMtm == KUidMsvLocalServiceMtm &&

         aEntry.iType == KUidMsvFolderEntry )

        {

        foundIndex = LocalEntryBitmapIndex( id );

        // check if folder has unread messages

        if ( id ==  KMsvGlobalInBoxIndexEntryId ||

//            id ==  KMceDocumentsEntryId ||

            id >= KFirstFreeEntryId

            )

            {

            TBool unreadMessages = EFalse;

            TRAPD(err, ( unreadMessages = HasUnreadMessagesL( id ) ) );

            if (err == KErrNone && unreadMessages )

                {

                foundIndex++;

                }

            }

        }

    if ( foundIndex == KErrNotFound )

        {

        TRAPD(err, ( foundIndex = LoadBitmapL( aEntry ) ) );

        if (err != KErrNone )

            {

            foundIndex = KErrNotFound;

            }

        }

    return ( foundIndex == KErrNotFound ?

        EMceBitmapIndexUnknown : foundIndex );

    }

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

// CMceOneRowBitmapResolver::LoadBitmapL

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

TInt CMceOneRowBitmapResolver::LoadBitmapL( const TMsvEntry& aEntry )

    {

    CBaseMtmUiData* uiData = iRegObserver.GetMtmUiDataL(aEntry.iMtm);

    if ( uiData )

        {

        TInt flags = 0;

        if ( aEntry.iType.iUid == KUidMsvServiceEntryValue ||

            aEntry.iType == KUidMsvFolderEntry)

            {

            TBool unreadMessages = EFalse;

            TRAPD( err, ( unreadMessages = HasUnreadMessagesL( aEntry.Id() ) ) );

            // leave error codes are filtered, because it is not important to know

            // if there are unread messages or not,

            // just different icon would be displayed

            if (err == KErrNone && unreadMessages )

                {

                flags = EMtudEntryStateOpen; // includes unread messages

                }

            //check for sub folders

            TMsvSelectionOrdering selectionOrdering( KMsvGroupByType, EMsvSortByNone, ETrue );

            CMsvEntry* entry = iSession->GetEntryL( aEntry.Id() );

            entry->SetSortTypeL( selectionOrdering );

            CleanupStack::PushL( entry );

            TInt index = entry->Count()-1;

            while ( ( index>=0 ) && ( (*entry)[index].iType != KUidMsvFolderEntry ) )

                {

                index--;

                }

            CleanupStack::PopAndDestroy( entry );

            if( index != -1 )

                {

                flags |= EMtudEntryStateSubFolder;

                }

            }

        const CBaseMtmUiData::CBitmapArray* bitmaps = NULL;

        bitmaps = &uiData->ContextIcon( aEntry, flags );

        if ( bitmaps )

            {

            CGulIcon* tempBmp = NULL;

            if ( bitmaps->Count() == 1 )

                {

                tempBmp = CGulIcon::NewL( bitmaps->At( 0 ) );

                }

            else if ( bitmaps->Count() > 1 )

                {

                tempBmp = CGulIcon::NewL( bitmaps->At( 0 ), bitmaps->At( 1 ) );

                }

            if ( tempBmp )

                {

                CleanupStack::PushL( tempBmp );

                tempBmp->SetBitmapsOwnedExternally( ETrue );

                TInt index = iIcons->Count() - 1;

                iIcons->AppendL( tempBmp ); // Array will be of count 22

                // index greater than 20 so 21 or 22

                if ( index > iBitmapsLoaded )

                    {

                    while ( iIcons->Count() != iBitmapsLoaded+1 )

                        {

                        CGulIcon* iconToBeDelete = iIcons->At( index );

                        iIcons->Delete( index );

                        delete iconToBeDelete;

                        index--;

                        }

                    }

                else

                    {

                    CGulIcon* iconToBeDelete = iIcons->At( index );

                    iIcons->Delete( index );

                    delete iconToBeDelete;

                    }

                CleanupStack::Pop(); // tempBmp

                }

            }

        else

            {

            return KErrNotFound;

            }

        }

    else

        {

        // something is wrong

        return EMceBitmapIndexUnknown;

        }

    return iIcons->Count() - 1;

    }

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

// CMceOneRowBitmapResolver::GetBitmapL

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

TInt CMceOneRowBitmapResolver::GetBitmapL( TMsvEntry& aEntry, CFbsBitmap*& aBitmap, CFbsBitmap*& aMask )

    {

    TInt index = BitmapIndex( aEntry );

    if ( index >= 0 )

        {

        CFbsBitmap* bitmap = NULL;

        CFbsBitmap* bitmapMask = NULL;

        CGulIcon* foundIcon = iIcons->At( index );

        bitmap = foundIcon->Bitmap();

        bitmapMask = foundIcon->Mask();

        aBitmap = bitmap;

        aMask = bitmapMask;

        // if this is found from the array already

        index = KErrNotFound;

        const TInt iconCount = iIconArray.Count();

        for (TInt i = 0; i < iconCount && index == KErrNotFound; i++)

            {

            if ( iIconArray.operator[](i).iBitmapPointer == bitmap )

                {

                index = iIconArray.operator[](i).iIconId;

                }

            }

        }

    return (index < 0 ? KErrNotFound : index );

    }

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

// CMceOneRowBitmapResolver::GetBitmapL

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

TInt CMceOneRowBitmapResolver::GetBitmapL( TMceBitmapArrayIndexes aBitmapIndex, CFbsBitmap*& aBitmap, CFbsBitmap*& aMask )

    {

    // or should it be ok just return iIconArray.operator[](aBitmapIndex).iIconId;

    CGulIcon* foundIcon = iIcons->At( aBitmapIndex );

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* bitmapMask = NULL;

    bitmap = foundIcon->Bitmap();

    bitmapMask = foundIcon->Mask();

    aBitmap = bitmap;

    aMask = bitmapMask;

    // if this is found from the array already

    TInt index = KErrNotFound;

    const TInt iconCount = iIconArray.Count();

    for (TInt i = 0; i < iconCount && index == KErrNotFound; i++)

        {

        if ( iIconArray.operator[](i).iBitmapPointer == bitmap )

            {

            index = iIconArray.operator[](i).iIconId;

            }

        }

    return index;

    }

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

// CMceOneRowBitmapResolver::AddTreeIconIdL

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

TInt CMceOneRowBitmapResolver::AddTreeIconIdL( 

    CFbsBitmap* aBitmap, 

    TInt aTreeIconIndex,

    TUid aMtmUid )

    {

    TMceHierListIconEntry iconEntry;

    iconEntry.iBitmapPointer = aBitmap;

    iconEntry.iIconId = aTreeIconIndex;

    iconEntry.iMtmUid = aMtmUid;

    iIconArray.AppendL( iconEntry );

    return iIconArray.Count();

    }

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

// CMceOneRowBitmapResolver::SetTreeIconId

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

void CMceOneRowBitmapResolver::SetTreeIconId( TMceBitmapArrayIndexes aBitmapIndex, TInt aTreeIconIndex )

    {

    iIconArray.operator[](aBitmapIndex).iIconId = aTreeIconIndex;

    }

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

// CMceOneRowBitmapResolver::TreeIconId

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

TInt CMceOneRowBitmapResolver::TreeIconId( TMceBitmapArrayIndexes aBitmapIndex )

    {

    return iIconArray.operator[](aBitmapIndex).iIconId;

    }

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

// CMceOneRowBitmapResolver::HasUnreadMessagesL

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

TBool CMceOneRowBitmapResolver::HasUnreadMessagesL( const TMsvId aId )

    {

    TBool unreadMessages = EFalse;

    CMsvEntry* entry = iSession->GetEntryL( aId );

    CleanupStack::PushL( entry );

    const TInt count = entry->Count();

    for ( TInt loop = 0; !unreadMessages && loop < count; loop++ )

        {

        if ( (*entry)[loop].iType.iUid == KUidMsvFolderEntryValue )

            {

            unreadMessages = HasUnreadMessagesL( (*entry)[loop].Id() );

            }

        else

            {

            unreadMessages = (*entry)[loop].Unread();

            }

        }

    CleanupStack::PopAndDestroy(); // entry

    return unreadMessages;

    }

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

// CMceOneRowBitmapResolver::LocalEntryBitmapIndex

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

TInt CMceOneRowBitmapResolver::LocalEntryBitmapIndex( TMsvId aEntryId ) const

    {

    TInt foundIndex = EMceBitmapIndexFolderSmall;

    switch( aEntryId )

        {

        case 0x1009: //KMceTemplatesEntryId:

            foundIndex = EMceBitmapIndexFolderTemp;

            break;

        default:

            // set in foundIndex declaration

            break;

        }

    return foundIndex;

    }

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

// CMceOneRowBitmapResolver::ChangeBitmapInIconArrayL

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

void CMceOneRowBitmapResolver::ChangeBitmapInIconArrayL(  )

    {

    if ( !iIcons )

        {

        // should not happen!

        return;

        }

    iIcons->ResetAndDestroy();

    MAknsSkinInstance* skins = AknsUtils::SkinInstance();

    CreateAndAppendIconL( 

        skins, 

        KAknsIIDQgnPropMceUnknownRead, 

        iFilenameMuiu, 

        EMbmMuiuQgn_prop_mce_unknown_read, 

        EMceOneRowBitmapLoadNormal );

    CreateAndAppendIconL( 

        skins, 

        KAknsIIDQgnPropMceTemplate, 

        iFilenameAvkon, 

        EMbmAvkonQgn_prop_folder_temp, 

        EMceOneRowBitmapLoadNormal );

    CreateAndAppendIconL( 

        skins, 

        KAknsIIDQgnPropFolderSmall, 

        iFilenameAvkon, 

        EMbmAvkonQgn_prop_folder_small, 

        EMceOneRowBitmapLoadNormal );

    CreateAndAppendIconL( 

        skins, 

        KAknsIIDQgnPropFolderSmallNew, 

        iFilenameAvkon, 

        EMbmAvkonQgn_prop_folder_small_new, 

        EMceOneRowBitmapLoadNormal );

    CreateAndAppendIconL( 

        skins, 

        KAknsIIDQgnIndiAttachementAdd, 

        iFilenameMuiu, 

        EMbmMuiuQgn_indi_attach_add, 

        EMceOneRowBitmapLoadSkinned );

    CreateAndAppendIconL( 

        skins, 

        KAknsIIDQgnIndiAttachementAdd, 

        iFilenameMuiu, 

        EMbmMuiuQgn_indi_attach_add, 

        EMceOneRowBitmapLoadSkinnedHighlight );

    CreateAndAppendIconL( 

        skins, 

        KAknsIIDQgnIndiMcePriorityHigh, 

        iFilenameAvkon, 

        EMbmAvkonQgn_indi_mce_priority_high, 

        EMceOneRowBitmapLoadSkinned );

    CreateAndAppendIconL( 

        skins, 

        KAknsIIDQgnIndiMcePriorityHigh,