/*
* 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:  An icon array for Phonebook 2 icons.
*
*/


// INCLUDE FILES
#include <CPbk2IconArray.h>

// Phonebook 2
#include <CPbk2IconFactory.h>
#include <CPbk2IconInfo.h>
#include <MPbk2FieldPropertyArray.h>
#include <MPbk2FieldProperty.h>
#include <TPbk2AppIconId.h>
#include <fbs.h>

// System includes
#include <barsread.h>       // TResourceReader
#include <gulicon.h>        // CGulIcon

// Debugging headers
#include <Pbk2Debug.h>


/// Unnamed namespace for local definitions
namespace {

const TInt KGranularity = 10;

#ifdef _DEBUG

enum TPanicCode
    {
    EPanicLogic_ReadArrayL
    };

void Panic(TInt aReason)
    {
    _LIT( KPanicText, "CPbk2IconArray" );
    User::Panic( KPanicText, aReason );
    }

#endif // _DEBUG

} /// namespace


/**
 * An array that hides TPbk2IconId.h include from header.
 */
class CPbk2IconArray::CIdArray : public CArrayFixFlat<TPbk2IconId>
    {
    public: // Constructor

        /**
         * Constructor.
         */
        CIdArray();
    };

// --------------------------------------------------------------------------
// CPbk2IconArray::CIdArray::CIdArray
// --------------------------------------------------------------------------
//
CPbk2IconArray::CIdArray::CIdArray() :
        CArrayFixFlat<TPbk2IconId>( KGranularity )
    {
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::CPbk2IconArray
// --------------------------------------------------------------------------
//
CPbk2IconArray::CPbk2IconArray() :
        CArrayPtrFlat<CGulIcon>( KGranularity ),
        iArrayId( EPbk2NullIconArrayId )
    {
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::~CPbk2IconArray
// --------------------------------------------------------------------------
//
CPbk2IconArray::~CPbk2IconArray()
    {
    // Free contents of this array for leave-safety
    ResetAndDestroy();
    delete iIconFactory;
    delete iIdMap;
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::NewL
// --------------------------------------------------------------------------
//
EXPORT_C CPbk2IconArray* CPbk2IconArray::NewL( TResourceReader& aReader )
    {
    CPbk2IconArray* self = new( ELeave ) CPbk2IconArray;
    CleanupStack::PushL( self );
    self->ConstructL( aReader );
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::NewL
// --------------------------------------------------------------------------
//
EXPORT_C CPbk2IconArray* CPbk2IconArray::NewL(
        const MPbk2FieldPropertyArray& aFieldProperties )
    {
    CPbk2IconArray* self = new( ELeave ) CPbk2IconArray;
    CleanupStack::PushL( self );
    self->ConstructL( aFieldProperties );
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::NewL
// --------------------------------------------------------------------------
//
EXPORT_C CPbk2IconArray* CPbk2IconArray::NewL( TResourceReader& aReader,
        const CPbk2IconInfoContainer& aIconInfoContainer )
    {
    CPbk2IconArray* self = new( ELeave ) CPbk2IconArray;
    CleanupStack::PushL( self );
    self->ConstructL( aReader, aIconInfoContainer );
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::BaseConstructL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::BaseConstructL()
    {
    iIdMap = new ( ELeave ) CIdArray;
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::ConstructL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::ConstructL()
    {
    BaseConstructL();
    CPbk2IconFactory* factory = CPbk2IconFactory::NewLC();
    AppendDefaultIconsL( *factory );
    CleanupStack::PopAndDestroy( factory );
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::ConstructL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::ConstructL( TResourceReader& aReader )
    {
    BaseConstructL();
    CPbk2IconFactory* factory = CPbk2IconFactory::NewLC();
    DoAppendIconsFromResourceL( aReader, *factory, ETrue );
    CleanupStack::PopAndDestroy( factory );
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::ConstructL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::ConstructL
        ( const MPbk2FieldPropertyArray& aFieldProperties )
    {
    BaseConstructL();
    CPbk2IconFactory* factory = CPbk2IconFactory::NewLC();
    AppendDefaultIconsL( *factory );

    const TInt count = aFieldProperties.Count();
    for ( TInt i = 0; i < count; ++i )
        {
        const TPbk2IconId& id = aFieldProperties.At(i).IconId();
        if ( FindIcon( id ) == KErrNotFound )
            {
            ReserveMemoryL( 1 ); // Reserve space for new icon
            AppendIconWithMappingL( *factory, id );
            }
        }
    CleanupStack::PopAndDestroy( factory );

    iArrayId = EPbk2FieldTypeIconArrayId;
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::ConstructL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::ConstructL( TResourceReader& aReader,
        const CPbk2IconInfoContainer& aIconInfoContainer )
    {
    BaseConstructL();
    AppendIconsFromResourceL( aReader, aIconInfoContainer );
    }
    
// --------------------------------------------------------------------------
// CPbk2IconArray::Id
// --------------------------------------------------------------------------
//
EXPORT_C TPbk2IconArrayId CPbk2IconArray::Id() const
    {
    return iArrayId;
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::FindIcon
// --------------------------------------------------------------------------
//
EXPORT_C TInt CPbk2IconArray::FindIcon( const TPbk2IconId& aIconId ) const
    {
    const TInt count = iIdMap->Count();
    for ( TInt i = 0; i < count; ++i )
        {
        if ( (*iIdMap)[i] == aIconId )
            {
            return i;
            }
        }
    return KErrNotFound;
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::FindAndCreateIconL
// --------------------------------------------------------------------------
//
EXPORT_C TInt CPbk2IconArray::FindAndCreateIconL
        ( const TPbk2IconId& aIconId )
    {
    TInt index = FindIcon( aIconId );
    if ( index == KErrNotFound )
        {
        if ( !iIconFactory )
            {
            iIconFactory = CPbk2IconFactory::NewL();
            }        
        ReserveMemoryL( 1 ); // reserve memory for the new icon
        AppendIconWithMappingL( *iIconFactory, aIconId );
        // last index
        index = Count() - 1;
        }
    else
        {
        // Delete factory it's not needed
        delete iIconFactory;
        iIconFactory = NULL;
        }
    return index;
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::AppendIconsFromResourceL
// --------------------------------------------------------------------------
//
EXPORT_C void CPbk2IconArray::AppendIconsFromResourceL(
        TResourceReader& aReader,
        const CPbk2IconInfoContainer& aIconInfoContainer )
    {
    CPbk2IconFactory* factory = CPbk2IconFactory::NewLC( aIconInfoContainer );
    DoAppendIconsFromResourceL( aReader, *factory, EFalse );
    CleanupStack::PopAndDestroy( factory );
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::RefreshL
// --------------------------------------------------------------------------
//
EXPORT_C void CPbk2IconArray::RefreshL()
    {
    CPbk2IconFactory* factory = CPbk2IconFactory::NewLC();
    DoRefreshL( *factory );
    CleanupStack::PopAndDestroy( factory );
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::RefreshL
// --------------------------------------------------------------------------
//
EXPORT_C void CPbk2IconArray::RefreshL(
        const CPbk2IconInfoContainer& aIconInfoContainer )
    {
    CPbk2IconFactory* factory = CPbk2IconFactory::NewLC( aIconInfoContainer );
    DoRefreshL( *factory );
    CleanupStack::PopAndDestroy( factory );
    }
    
// --------------------------------------------------------------------------
// CPbk2IconArray::AppendIconL
// --------------------------------------------------------------------------
//
EXPORT_C void CPbk2IconArray::AppendIconL( 
        CGulIcon* aIcon,  const TPbk2IconId& aIconId ) 
    {
    ReserveMemoryL( 1 ); // Reserve space for new icon and iconId
    AppendL( aIcon );
    iIdMap->AppendL( aIconId );
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::AppendIconL
// --------------------------------------------------------------------------
//
EXPORT_C void CPbk2IconArray::AppendIconL( CPbk2IconInfo* aIconInfo ) 
    {
    if ( !iIconFactory )
        {
        iIconFactory = CPbk2IconFactory::NewL();
        }        

    iIconFactory->AppendIconL(aIconInfo );
    AppendIconWithMappingL(*iIconFactory, aIconInfo->Pbk2IconId());
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::RemoveIcon
// --------------------------------------------------------------------------
//
EXPORT_C TInt CPbk2IconArray::RemoveIcon(
		const TPbk2IconId& aIconId )
	{
	// search the icon first
	const TInt count = iIdMap->Count();
	for ( TInt i = 0; i < count; ++i )
		{
		if ( (*iIdMap)[i] == aIconId )
			{
			//remove id from the array
			iIdMap->Delete( i );
			// get object
			CGulIcon* icon = At(i);
			delete icon;
			//remove pointer from the array 
			Delete( i );
			return KErrNone;
			}
		}
	return KErrNotFound;
	}

// --------------------------------------------------------------------------
// CPbk2IconArray::AppendDefaultIconsL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::AppendDefaultIconsL(
        const CPbk2IconFactory& aIconFactory )
    {
    TPbk2AppIconId markId( EPbk2qgn_indi_marked_add );
    TPbk2AppIconId emptyId( EPbk2qgn_prop_nrtyp_empty );
    ReserveMemoryL( 2 ); // num of added icons
    AppendIconWithMappingL( aIconFactory, markId );
    AppendIconWithMappingL( aIconFactory, emptyId );
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::DoAppendIconsFromResourceL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::DoAppendIconsFromResourceL( TResourceReader& aReader,
        const CPbk2IconFactory& aIconFactory, TBool aUpdateId )
    {
    TInt8 id = aReader.ReadInt8();
    if ( aUpdateId )
        {
        iArrayId = static_cast<TPbk2IconArrayId>( id );
        }

    TInt count = aReader.ReadInt16();
    ReserveMemoryL( count );

    while ( count-- > 0 )
        {
        TPbk2IconId iconId( aReader );
        AppendIconWithMappingL( aIconFactory, iconId );
        }
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::AppendIconWithMappingL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::AppendIconWithMappingL
        ( const CPbk2IconFactory& aIconFactory, const TPbk2IconId& aIconId )
    {
    CGulIcon* gulIcon = aIconFactory.CreateIconLC( aIconId );
    __ASSERT_DEBUG(gulIcon, Panic(EPanicLogic_ReadArrayL));
    AppendL( gulIcon );
    CleanupStack::Pop( gulIcon );
    iIdMap->AppendL( aIconId );
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::ReserveMemoryL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::ReserveMemoryL( TInt aAmount )
    {
    SetReserveL( Count() + aAmount );
    iIdMap->SetReserveL( iIdMap->Count() + aAmount );
    }

// --------------------------------------------------------------------------
// CPbk2IconArray::DoRefreshL
// --------------------------------------------------------------------------
//
void CPbk2IconArray::DoRefreshL( const CPbk2IconFactory& aFactory )
    {
    const TInt count = iIdMap->Count();
    for (TInt i = 0; i < count; ++i)
        {
        const TPbk2IconId& iconId = iIdMap->At(i);
        CGulIcon* gulIcon = aFactory.CreateIconL( iconId );
        if ( gulIcon )
            {
            // replace the old icon only if new one was loaded
            delete At(i);
            At(i) = gulIcon;
            }
        }
    }

//  End of File