/*
* Copyright (c) 2004-2005 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:  
*       Implements the CLandmarksCategoriesModel class and some help functions
*
*/



#include <eikenv.h>
#include <gulicon.h>
#include <AknsUtils.h>
#include <AknsItemID.h>

#include <EPos_CPosLandmarkCategory.h>

#include <lmrefapp.mbg>
#include "LandmarksCommonData.h"
#include "LandmarksCategoriesModel.h"

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// DefaultIconIndex returns the icon index of the appropriate default icon.
// User defined categories have different default icons than global ones.
//
// Returns: an icon index
// Param:   aCategory the category to investigate
// -----------------------------------------------------------------------------
//
TInt DefaultIconIndex(CPosLandmarkCategory& aCategory)
    {
    // Global categories have different default icon than user-defined.
    TBool isGlobal = aCategory.GlobalCategory() != KPosLmNullGlobalCategory;

    if (isGlobal)
        {
        return KDefaultGlobalIconIndex;
        }
    else
        {
        return KDefaultUserIconIndex;
        }
    }

// -----------------------------------------------------------------------------
// ResetAndDestroyIcons
// Resets and destroys an array of icons. This function is used as a 
// TCleanupOperation.
// Params: aAny: The icons array to reset ands destroy
// -----------------------------------------------------------------------------
//
void ResetAndDestroyIcons(TAny* aAny)
    {
    CIconList* icons = reinterpret_cast <CIconList*> (aAny);
    for (TInt i = 0; i < icons->Count(); i++)
        {
        delete &icons[i];
        }
    icons->Reset();
    }

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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CLandmarksCategoriesModel::CLandmarksCategoriesModel()
	{
	}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksCategoriesModel::ConstructL()
	{
	// The list box model uses MDesCArray interface class to take in text items.
	iListItems = new(ELeave) CDesCArraySeg(KGranularity);
	}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CLandmarksCategoriesModel* CLandmarksCategoriesModel::NewL()
    {
    CLandmarksCategoriesModel* self = 
        new (ELeave) CLandmarksCategoriesModel();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CLandmarksCategoriesModel::~CLandmarksCategoriesModel()
	{
	delete iListItems;
	}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksCategoriesModel::SetItemIds(RArray<TPosLmItemId>* aItemIds)
    {
    iItemIds = aItemIds;

    // Empty descriptor model
    iListItems->Reset();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CDesCArraySeg* CLandmarksCategoriesModel::ItemList()
    {
    return iListItems;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksCategoriesModel::SetCurrentItem(TInt aIndex) 
    {
    iCurrentItem = aIndex;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TPosLmItemId CLandmarksCategoriesModel::CurrentItemId()
    {
    if (iCurrentItem < 0 || iCurrentItem > iItemIds->Count() - 1)
        {
        return KPosLmNullItemId;
        }

    return (*iItemIds)[iCurrentItem];
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CIconList* CLandmarksCategoriesModel::CreateIconListL()
    {
    CIconList* iconList = new (ELeave) CArrayPtrFlat<CGulIcon>(KGranularity);
    CleanupStack::PushL(TCleanupItem(ResetAndDestroyIcons, iconList));
    
    // Create the global category icon consisting of its image and mask.
    TAknsItemID aknsItemId ={0,0};
    CGulIcon* icon = AknsUtils::CreateGulIconL(NULL, aknsItemId,
        KLandmarksMbmFileName, 
        EMbmLmrefappCategory_global, 
        EMbmLmrefappCategory_global_mask);
    CleanupStack::PushL(icon);
    icon->SetBitmapsOwnedExternally(EFalse); 
    iconList->AppendL(icon);
    CleanupStack::Pop(icon);

    // Create the user defined category icon consisting of its image and mask.
    icon = AknsUtils::CreateGulIconL(NULL, aknsItemId,
        KLandmarksMbmFileName, 
        EMbmLmrefappCategory_user, 
        EMbmLmrefappCategory_user_mask);
    CleanupStack::PushL(icon);
    icon->SetBitmapsOwnedExternally(EFalse); 
    iconList->AppendL(icon);
    CleanupStack::Pop(icon);
    
    CleanupStack::Pop(); // iconList

    // initialze iIconList. We don't need to delete any possible previous 
    // iIconList since ownership is transferred to calling object.
    iIconList = iconList;

    return iconList;
    }

// -----------------------------------------------------------------------------
// Refreshes a part of the model. Those categories that have been read from the 
// database overwrites old categories. The model is refreshed incrementally 
// from top to bottom.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CLandmarksCategoriesModel::RepopulateModelL(
    CArrayPtr<CPosLandmarkCategory>* aCategories)
    {
    TInt nrOfReadItems = aCategories->Count();

    // Format and insert the read categories
    for (TInt i = 0; i < nrOfReadItems; i++)
        {
        // Format name and icon
        CPosLandmarkCategory* category = (*aCategories)[i];
        HBufC* formattedName = FormatListItemLC(*category);

        // Insert formatted descriptor into model
        iListItems->AppendL(*formattedName);

        CleanupStack::PopAndDestroy(formattedName);
        }
    }

// -----------------------------------------------------------------------------
// Formats a list item to the following format "X\tcategoryName"
// where X = icon index
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
HBufC* CLandmarksCategoriesModel::FormatListItemLC(CPosLandmarkCategory& aCategory)
    {
    // Extract name
    TPtrC name;
    aCategory.GetCategoryName(name);
    // 10 extra chars for icon index and column separator
    const TInt KExtraChars = 10;
    HBufC* formattedNameBuf = HBufC::NewLC(name.Length() + KExtraChars);
    TPtr formattedNamePtr = formattedNameBuf->Des();

    // Extract icon info
    TPtrC mbmIconFile;
    TInt iconIndex, maskIndex;
    TInt res = aCategory.GetIcon(mbmIconFile, iconIndex, maskIndex);

    // Format list item
    if (res == KErrNone)
        {
        // Create icon and append it to icon array. 
        TRAPD(err, AppendIconL(mbmIconFile, iconIndex, maskIndex));
        if (err == KErrNone)
            {
            // Append the array index where the icon is appended
            formattedNamePtr.AppendNum(iIconList->Count() - 1);
            }
        else // Unable to create icon, use appropriate default icon.
            {
            formattedNamePtr.AppendNum(DefaultIconIndex(aCategory));
            }
        }
    else // res == KErrNotFound
        {
        formattedNamePtr.AppendNum(DefaultIconIndex(aCategory));
        }
    formattedNamePtr.Append(KTab);
    formattedNamePtr.Append(name);

    return formattedNameBuf;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksCategoriesModel::AppendIconL(
    const TDesC& aMbmFile, 
    TInt aIconOffset, 
    TInt aMaskOffset)
    {
    TAknsItemID aknsItemId = {0,0};
    CGulIcon* icon = AknsUtils::CreateGulIconL(NULL, aknsItemId,
        aMbmFile, 
        aIconOffset, 
        aMaskOffset);
    CleanupStack::PushL(icon);
    icon->SetBitmapsOwnedExternally(EFalse);
    iIconList->AppendL(icon);
    CleanupStack::Pop(icon);
    }