/*

* Copyright (c) 2002 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:    LandmarksUi Content File -

*

*/

// INCLUDE FILES

#include "EPos_CPosLandmarkDatabase.h"

#include <EPos_CPosLmCategoryManager.h>

#include "CLmkParseAllWrapper.h"

#include <EPos_CPosLandmarkParser.h>

#include <EPos_CPosLmOperation.h>

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLmOperation.h>

#include "CLmkAOOperation.h"

#include "CLmkLandMarkCategoriesName.h"

#include <lmkerrors.h>

#if defined(_DEBUG)

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

_LIT( KPanicMsg, "CLmkParseAllWrapper" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

}  // namespace

#endif

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

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

// CLmkParseAllWrapper::CLmkParseAllWrapper

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

// might leave.

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

//

CLmkParseAllWrapper::CLmkParseAllWrapper(

    CPosLandmarkParser& aParser,

    MLmkAOOperationObserver& aObserver,

    CPosLandmarkDatabase& aDb )

    : iParser( aParser ),

      iObserver( aObserver),

      iDb(aDb)

    {

    }

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

// CLmkParseAllWrapper::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkParseAllWrapper::ConstructL()

    {

    }

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

// CLmkParseAllWrapper::NewL

// Two-phased constructor.

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

//

CLmkParseAllWrapper* CLmkParseAllWrapper::NewL(

    CPosLandmarkParser& aParser,

    MLmkAOOperationObserver& aObserver,

    CPosLandmarkDatabase& aDb )

    {

    CLmkParseAllWrapper* self =

        new ( ELeave ) CLmkParseAllWrapper( aParser, aObserver, aDb );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CLmkParseAllWrapper::~CLmkParseAllWrapper

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

//

CLmkParseAllWrapper::~CLmkParseAllWrapper()

    {

    iLmkLandmarks.ResetAndDestroy();

    iCategoriesNames.ResetAndDestroy();

    delete iAOOperation;

    }

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

// CLmkParseAllWrapper::ParseAllL

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

//

void CLmkParseAllWrapper::ParseAllL()

    {

    CPosLmOperation* operation = iParser.ParseContentL();

    __ASSERT_DEBUG( !iAOOperation, Panic( KLmkPanicAlreadyActive ) );

    iAOOperation =

        CLmkAOOperation::NewL( operation,

                               *this,

                               MLmkAOOperationObserver::EParse,

                               ETrue );

    iAOOperation->StartOperation();

    }

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

// CLmkParseAllWrapper::LandmarkLC

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

//

CPosLandmark* CLmkParseAllWrapper::LandmarkLC( TUint aLandmarkIndex )

    {

    __ASSERT_DEBUG( aLandmarkIndex < TUint( iLmkLandmarks.Count() ),

                    Panic( KLmkPanicInvalidIndex ) );

    CLmkLandmark* lmkLandmarks = iLmkLandmarks[aLandmarkIndex];

    CPosLandmark* landmark = lmkLandmarks->PosLandmark();

    return CPosLandmark::NewLC( *landmark );

    }

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

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

// CLmkParseAllWrapper::CategoryNameLC

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

//

CLmkLandMarkCategoriesName* CLmkParseAllWrapper::CategoryNameLC( TUint aLandmarkIndex )

    {

    __ASSERT_DEBUG( aLandmarkIndex < TUint( iCategoriesNames.Count() ),

                    Panic( KLmkPanicInvalidIndex ) );

	CLmkLandMarkCategoriesName* category = CLmkLandMarkCategoriesName::NewL( *iCategoriesNames[aLandmarkIndex]);

	CleanupStack::PushL(category);

	return category;

    }

// CLmkParseAllWrapper::HandleOperationL

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

//

void CLmkParseAllWrapper::HandleOperationL(

    TOperationTypes aType,

    TReal32 aProgress,

    TInt aStatus )

    {

    __ASSERT_DEBUG( aType == EParse, Panic( KLmkPanicUnknownOperation ) );

    if ( aStatus == KPosLmOperationNotComplete ||

         aStatus == KErrNone )

        {

        CPosLandmark* landmark = iParser.LandmarkLC();

	        CLmkLandMarkCategoriesName* categoryNames = CLmkLandMarkCategoriesName::NewL();

	    	CleanupStack::PushL(categoryNames);

	        RArray<TPosLmItemId>*  categoryIdArray = new(ELeave) RArray<TPosLmItemId>;

	        CleanupClosePushL(*categoryIdArray);

	    	landmark->GetCategoriesL( *categoryIdArray );

	    	HBufC* catName = HBufC::NewLC( KPosLmMaxCategoryNameLength );

	    	TPtrC categoryPtr(catName->Des());

	    	RPointerArray<CPosLandmarkCategory>* categories = new(ELeave) RPointerArray<CPosLandmarkCategory>;

	    	CleanupClosePushL(*categories);

	        for( TInt cnt = 0; cnt < categoryIdArray->Count(); cnt++ )

	            {

	            CPosLandmarkCategory *category = iParser.LandmarkCategoryLC((*categoryIdArray)[cnt]);

	            category->GetCategoryName( categoryPtr );

	            /*

	             * For predefined category, find the name from local database and

	             * display the localised names to the user

	             * If received predefined category does not exist in the local db,

	             * then treat is as a newly received category

	             */

	            if ( category->GlobalCategory() != KPosLmNullGlobalCategory ) // global category

	                {

	                // Get the name from db (localised name for predefined category is stored in db)

	                HBufC* globCatName = NULL;

	                CPosLmCategoryManager* categoryMgr = CPosLmCategoryManager::NewL( iDb );

		            CleanupStack::PushL( categoryMgr );

		            globCatName = categoryMgr->GlobalCategoryNameL( category->GlobalCategory() );

		            if ( globCatName == NULL )

	    	            {

	    	            categoryNames->AddCategoryName( categoryPtr );

	    	            }

	    	        else

	        	        {

	        	        CleanupStack::PushL( globCatName );

	                    if ( globCatName->Length() > 0 )

	                        {

	                        // Add it to categories to be shown

	                        categoryNames->AddCategoryName( *globCatName );

	                        }

	                    CleanupStack::PopAndDestroy( globCatName );

	        	        }

		            CleanupStack::PopAndDestroy( categoryMgr );

	                }

	            else // User defined categories

	                {

	                categoryNames->AddCategoryName( categoryPtr );

	                }

	            User::LeaveIfError(categories->Append(category));

	            CleanupStack::Pop(category);

	            }

	    	//categoryIdArray->Close();

	    	CLmkLandmark* lmkLandmarks = CLmkLandmark::NewL(landmark,*categories);

	    	CleanupStack::PushL(lmkLandmarks);

	        User::LeaveIfError( iLmkLandmarks.Append( lmkLandmarks ) );

	        User::LeaveIfError( iCategoriesNames.Append( categoryNames ) ); //Owner ship transferred to array

	        CleanupStack::Pop();//lmkLandmarks

	        CleanupStack::Pop( );//categories

	        categories->ResetAndDestroy();

	        delete categories;

	        CleanupStack::PopAndDestroy( 2 ); //catName,categoryIdArray

	        delete categoryIdArray;

	        CleanupStack::Pop();//categoryNames

	        CleanupStack::PopAndDestroy();//landmark

        }

    if ( aStatus != KPosLmOperationNotComplete )

        { // parsing finished or error occured

        __ASSERT_DEBUG( iAOOperation, Panic( KLmkPanicNullMember ) );

        delete iAOOperation;

        iAOOperation = NULL;

        iObserver.HandleOperationL( aType, aProgress, aStatus );

        }

    }

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

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

// CLmkParseAllWrapper::NumOfLandmarks

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

//

TInt CLmkParseAllWrapper::NumOfLandmarks()

	{

	return iLmkLandmarks.Count();

	}

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

// CLmkParseAllWrapper::LmkLandmarkLC

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

//

CLmkLandmark* CLmkParseAllWrapper::LmkLandmarkLC( TInt aLandmarkIndex )

	{

	__ASSERT_DEBUG( aLandmarkIndex < TUint( iLmkLandmarks.Count() ),

                    Panic( KLmkPanicInvalidIndex ) );

    CLmkLandmark* landmark = iLmkLandmarks[aLandmarkIndex];

    CLmkLandmark* lmkLandmarks = CLmkLandmark::NewL( *landmark );

    CleanupStack::PushL(lmkLandmarks);

    return lmkLandmarks;

	}

//  End of File