/*
* 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 CLandmarksModel class
*
*/



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

#include <EPos_CPosLandmark.h>

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


const TInt KDefaultIconIndex = 0;

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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CLandmarksModel::CLandmarksModel()
	{
	}

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

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

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

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

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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CDesCArraySeg* CLandmarksModel::ItemList()
    {
    return iListItems;
    }
		
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksModel::SetCurrentItem(TInt aIndex) 
    {
    iCurrentItem = aIndex;
    }

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

    return (*iItemIds)[iCurrentItem];
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksModel::GetItemIdsL( 
    const CArrayFix<TInt>& aSelectionIndexes,
    RArray<TPosLmItemId>& aItemIds )
    {
	CleanupClosePushL(aItemIds);
	
    aItemIds.Reset();
    if ( iItemIds )
        {
        for ( TInt i = 0; i < aSelectionIndexes.Count(); i++ )
            {
            if ( i < iItemIds->Count() )
                {
                aItemIds.AppendL( (*iItemIds)[aSelectionIndexes[i]] );
                }
            else
                {
                break;
                }
            }
        }
		
	CleanupStack::Pop(&aItemIds);
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CIconList* CLandmarksModel::CreateIconListL()
    {
    CIconList* iconList = 
        (CIconList*) new (ELeave) CArrayPtrFlat<CGulIcon>(KGranularity);
    CleanupStack::PushL(iconList);
    
    // Create the default landmark icon consisting of its image and mask
    TAknsItemID aknsItemId = {0,0};
    CGulIcon* icon = AknsUtils::CreateGulIconL(NULL, aknsItemId,
        KLandmarksMbmFileName, 
        EMbmLmrefappDefault_lm, 
        EMbmLmrefappDefault_lm_mask);
    CleanupStack::PushL(icon);
    icon->SetBitmapsOwnedExternally(EFalse);
    iconList->AppendL(icon);
    CleanupStack::Pop(2, iconList);

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

    return iIconList;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksModel::RepopulateModelL(
    CArrayPtr<CPosLandmark>* aLandmarks)
    {
    TInt nrOfReadItems = aLandmarks->Count();

    // Format and insert the read landmarks
    for (TInt i = 0; i < nrOfReadItems; i++)
        {
        CPosLandmark* landmark = (*aLandmarks)[i];
        HBufC* formattedListItem = FormatListItemLC(*landmark);
        iListItems->AppendL(*formattedListItem);
        CleanupStack::PopAndDestroy(formattedListItem);
        }
    }

// -----------------------------------------------------------------------------
// Formats a list item to the following format "X\tlandmarkName\t"
// where X = icon index
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
HBufC* CLandmarksModel::FormatListItemLC(CPosLandmark& aLandmark)
    {
    // Extract name
    TPtrC name;
    aLandmark.GetLandmarkName(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 = aLandmark.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
            {
            formattedNamePtr.AppendNum(KDefaultIconIndex);
            }
        }
    else // res == KErrNotFound
        {
        formattedNamePtr.AppendNum(KDefaultIconIndex);
        }
    formattedNamePtr.Append(KTab);
    formattedNamePtr.Append(name);

    return formattedNameBuf;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksModel::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);
    }