/*

* Copyright (c) 2002-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:    LandmarksUi Content File -    This contains methods implementing a combined dialog for Landmarks

*                by name view and categories view

*

*/

// INCLUDE FILES

#include <eikapp.h>

#include <eikenv.h>

#include <StringLoader.h>

#include <AknsUtils.h>

#include <akntabgrp.h>

#include <eikspane.h>

#include <aknnavide.h>

#include <aknnavi.h>

#include <barsread.h>

#include <lmkui.rsg>

#include <EPos_CPosLmCategoryCriteria.h>

#include "LmkConsts.h"

#include "landmarks.hrh"

#include "CLmkDbUtils.h"

#include "CLmkLmItemListProvider.h"

#include "CLmkUiUtils.h"

#include "CLmkSelectorDialog.h"

#include "CLmkEmptyDialog.h"

#include "CLmkDlgLmSelectorImpl.h"

#include "CLmkDlgCategorySelectorImpl.h"

#include "CLmkDlgCombiSelectorImpl.h"

#include "CLmkLmItemListMemento.h"

#include <lmkerrors.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

const TInt KLmkNumberOfSelectors = 3;

#if defined(_DEBUG)

_LIT( KPanicMsg, "CLmkDlgCombiSelectorImpl" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

#endif

}  // namespace

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

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

// CLmkDlgCombiSelectorImpl::CLmkDlgCombiSelectorImpl

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

// might leave.

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

//

CLmkDlgCombiSelectorImpl::CLmkDlgCombiSelectorImpl( CPosLandmarkDatabase& aDb )

    : CLmkDlgSelectorImplBase( aDb ),

      iSelectorState( ELmkInitialState ),

      iSelectors( KLmkNumberOfSelectors ),

      iMementos( KLmkNumberOfSelectors ),

      iNavigating( EFalse ),

      iAlwaysModify( EFalse ),

      iCustomLandmarksTitle(0)

    {

    }

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

// CLmkDlgCombiSelectorImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkDlgCombiSelectorImpl::ConstructL()

    {

    BaseConstructL();

    // Default status pane:

    CEikStatusPane* sp = iEnv->AppUiFactory()->StatusPane();

    // Fetch pointer to the default navi pane control:

    iNaviPane = static_cast<CAknNavigationControlContainer*>(

                        sp->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );

    __ASSERT_DEBUG( iNaviPane, Panic( KLmkPanicNullMember ) );

    iNaviDeco = iNaviPane->CreateTabGroupL();

   	iNaviDeco->SetControlType( CAknNavigationDecorator::ETabGroup );

    iTabGroup = static_cast<CAknTabGroup*>( iNaviDeco->DecoratedControl() );

    __ASSERT_DEBUG( iTabGroup, Panic( KLmkPanicNullMember ) );

    // Add Tab Icons

    AddTabsL( *iTabGroup );

    // Set observer for CAknTabGroup

    iTabGroup->SetObserver( this );

    // Create mementos and initialize selector array with NULL pointers:

    MLmkListMemento* memento = NULL;

    for ( TInt i( 0 ); i < KLmkNumberOfSelectors; ++i )

        {

        memento = MementoL();

        User::LeaveIfError( iMementos.Append( memento ) );

        User::LeaveIfError( iSelectors.Append( NULL ) );

        }

    }

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

// CLmkDlgCombiSelectorImpl::NewL

// Two-phased constructor.

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

//

EXPORT_C CLmkDlgCombiSelectorImpl* CLmkDlgCombiSelectorImpl::NewL(

    CPosLandmarkDatabase& aDb )

    {

    CLmkDlgCombiSelectorImpl* self =

        new( ELeave ) CLmkDlgCombiSelectorImpl( aDb );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CLmkDlgCombiSelectorImpl::~CLmkDlgCombiSelectorImpl

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

//

CLmkDlgCombiSelectorImpl::~CLmkDlgCombiSelectorImpl()

    {

    iSelectors.ResetAndDestroy();

    iMementos.ResetAndDestroy();

    delete iNaviDeco;

    if( iCustomLandmarksTitle )

    	delete iCustomLandmarksTitle;

    }

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

// CLmkDlgCombiSelectorImpl::StopExecutionL

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

//

void CLmkDlgCombiSelectorImpl::StopExecutionL()

    {

    __ASSERT_DEBUG( iSelectors.Count() == KLmkNumberOfSelectors,

                    Panic( KLmkPanicSelectorArrayIndex ) );

    for ( TInt i( 0 ); i < KLmkNumberOfSelectors; ++i )

        {

        if ( iSelectors[i] )

            {

            iSelectors[i]->StopExecutionL();

            }

        }

    iNaviPane->Pop( iNaviDeco );

    // Dialog ExecuteL returns and we must consider it in final state

    iSelectorState = ELmkFinalState;

    }

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

// CLmkDlgCombiSelectorImpl::ExecuteL

//

// (other items were commented in a header).

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

//

TInt CLmkDlgCombiSelectorImpl::ExecuteL(

    TPosLmItemId& aOpenedItem,

    TBool aAlwaysModifyOpened )

    {

    // Ensure that ExecuteL is not already running:

    __ASSERT_DEBUG( iSelectorState == ELmkFinalState ||

                    iSelectorState == ELmkInitialState,

                    Panic( KLmkPanicIllegalMethodCall ) );

    iSelectorState = ELmkInitialState;

    iOpenedItem = &aOpenedItem;

    iAlwaysModify = aAlwaysModifyOpened;

    CLmkEmptyDialog * lDlg = new(ELeave)CLmkEmptyDialog();

    lDlg->SetMopParent(iMopParent);

	lDlg->ExecuteLD(R_EMPTY_DIALOG);

    TLmkSelectorStateEvent nextEvent( ELmkSelectorStart );

    do

        {

        nextEvent = HandleAnyStateEventL( nextEvent );

        } while ( nextEvent != ELmkSelectorNoEvent );

    lDlg->EmptyDialogExitL();

    return iDlgRetVal;

    }

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

// CLmkDlgCombiSelectorImpl::ExecuteL

//

// (other items were commented in a header).

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

//

TInt CLmkDlgCombiSelectorImpl::ExecuteL(

     RArray<TPosLmItemId>& aSelectedItems,

     TBool aAlwaysModifySelected )

    {

    // Ensure that ExecuteL is not already running:

    __ASSERT_DEBUG( iSelectorState == ELmkFinalState ||

                    iSelectorState == ELmkInitialState,

                    Panic( KLmkPanicIllegalMethodCall ) );

    iSelectorState = ELmkInitialState;

    iSelectedItems = &aSelectedItems;

    iAlwaysModify = aAlwaysModifySelected;

    TLmkSelectorStateEvent nextEvent( ELmkSelectorStart );

    do

        {

        nextEvent = HandleAnyStateEventL( nextEvent );

        } while ( nextEvent != ELmkSelectorNoEvent );

    return iDlgRetVal;

    }

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

// CLmkDlgCombiSelectorImpl::HandleAnyStateEventL

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

//

CLmkDlgCombiSelectorImpl::TLmkSelectorStateEvent

CLmkDlgCombiSelectorImpl::HandleAnyStateEventL(

    TLmkSelectorStateEvent aEvent )

    {

    TLmkSelectorStateEvent nextEvent( ELmkSelectorNoEvent );

    switch ( iSelectorState )

        {

        case ELmkInitialState:

            {

            nextEvent = HandleInitialStateEventL( aEvent );

            break;

            }

        case ELmkLandmarkSelector:

            {

            nextEvent = HandleLandmarkSelectorStateEventL( aEvent );

            break;

            }

        case ELmkCategorySelector:

            {

            nextEvent = HandleCategorySelectorStateEventL( aEvent );

            break;

            }

        case ELmkFilteredLmSelector:

            {

            nextEvent = HandleFilteredLmSelectorStateEventL( aEvent );

            break;

            }

        default: // ELmkFinalState

            {

            nextEvent = HandleDefaultStateStateEventL( aEvent );

            }

        }

    if ( iNavigating )

        { // navigation variable overrides dialog return value

        iNavigating = EFalse;

        nextEvent = ELmkSelectorNavigating;

        }

    return nextEvent;

    }

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

// CLmkDlgCombiSelectorImpl::HandleInitialStateEventL

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

//

CLmkDlgCombiSelectorImpl::TLmkSelectorStateEvent

CLmkDlgCombiSelectorImpl::HandleInitialStateEventL(

    TLmkSelectorStateEvent /*aEvent*/ )

    {

    iTabGroup->SetActiveTabById( ETabLandmarkList );

    iNaviPane->PushL( *iNaviDeco );

    iSelectorState = ELmkLandmarkSelector;

    CLmkDlgSelectorImplBase& selector = CurrentStateSelectorL();

    if ( iSelectedItems )

        { // multi selector mode

        iDlgRetVal = selector.ExecuteL( *iSelectedItems, iAlwaysModify );

        }

    else

        { // single selector mode

        iDlgRetVal = selector.ExecuteL( *iOpenedItem, iAlwaysModify );

        }

    return ELmkSelectorStop;

    }

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

// CLmkDlgCombiSelectorImpl::HandleAnyStateEventL

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

//

CLmkDlgCombiSelectorImpl::TLmkSelectorStateEvent

CLmkDlgCombiSelectorImpl::HandleLandmarkSelectorStateEventL(

    TLmkSelectorStateEvent aEvent )

    {

    __ASSERT_DEBUG( aEvent == ELmkSelectorNavigating ||

                    aEvent == ELmkSelectorStop,

                    Panic( KLmkPanicUnexpectedEvent ) );

    if ( aEvent == ELmkSelectorNavigating )

        {

        iSelectorState = ELmkCategorySelector;

        CLmkDlgSelectorImplBase& selector = CurrentStateSelectorL();

        iDlgRetVal = selector.ExecuteL( iCategoryIndex );

        return ELmkSelectorStop;

        }

    else

        { // aEvent == ELmkSelectorStop

        iSelectorState = ELmkFinalState;

        return ELmkSelectorNoEvent;

        }

    }

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

// CLmkDlgCombiSelectorImpl::HandleCategorySelectorStateEventL

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

//

CLmkDlgCombiSelectorImpl::TLmkSelectorStateEvent

CLmkDlgCombiSelectorImpl::HandleCategorySelectorStateEventL(

    TLmkSelectorStateEvent aEvent )

    {

    __ASSERT_DEBUG( aEvent == ELmkSelectorNavigating ||

                    aEvent == ELmkSelectorStop,

                    Panic( KLmkPanicUnexpectedEvent ) );

    if ( aEvent == ELmkSelectorNavigating )

        {

        iSelectorState = ELmkLandmarkSelector;

        CLmkDlgSelectorImplBase& selector = CurrentStateSelectorL();

        if ( iSelectedItems )

            { // multi selector mode

            iDlgRetVal = selector.ExecuteL( *iSelectedItems, iAlwaysModify );

            }

        else

            { // single selector mode

            iDlgRetVal = selector.ExecuteL( *iOpenedItem, iAlwaysModify );

            }

        return ELmkSelectorStop;

        }

    else if ( aEvent == ELmkSelectorStop && iDlgRetVal != 0 )

        { // -> open category contents

        TPosLmItemId categoryId( KPosLmNullItemId );

        static_cast<const CLmkLmItemListProvider&>( ListProvider() ).

            GetSelectedItemId( categoryId, iCategoryIndex );

		HBufC* catName = NULL;

        if (categoryId == KPosLmNullItemId) // 'uncategorised' category

        {

	        // 'uncategorised' category

	        // set criteria for searchnig 'Uncategorised' landmarks

			catName = StringLoader::LoadL(

			        R_LMK_LM_LIST_UNCATEGORISED,

			        const_cast<CEikonEnv *>( iEnv ));

        }

        else

        {

           //HBufC* catName = CLmkDbUtils::CategoryNameL( iDb, categoryId );

           catName = CLmkDbUtils::CategoryNameL( iDb, categoryId );

        }

        CleanupStack::PushL( catName );

        //Store old and create new navi pane

        iLmkUiUtils->StoreNaviPaneL();

        iLmkUiUtils->CreateNaviLabelL( *catName );

        CleanupStack::PopAndDestroy(); //catName

        iSelectorState = ELmkFilteredLmSelector;

        CLmkDlgSelectorImplBase& selector = CurrentStateSelectorL( categoryId );

		if(iMementos[iSelectorState])

	    	{

	    	CLmkLmItemListMemento* memento =

				 static_cast<CLmkLmItemListMemento*>(iMementos[iSelectorState]);

	    	memento->UpdateModelAvailability(EFalse);

	    	}

        if ( iSelectedItems )

            { // Return value is stored even if "Back" was pressed:

            iDlgRetVal = selector.ExecuteL( *iSelectedItems, ETrue );

            }

        else

            { // Return value is not stored if "Back" was pressed:

            iDlgRetVal = selector.ExecuteL( *iOpenedItem, EFalse );

            }

        return ELmkSelectorStop;

        }

    else // aEvent == ELmkSelectorStop && dialog canceled

        {

        iSelectorState = ELmkFinalState;

        return ELmkSelectorNoEvent;

        }

    }

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

// CLmkDlgCombiSelectorImpl::HandleFilteredLmSelectorStateEventL

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

//

CLmkDlgCombiSelectorImpl::TLmkSelectorStateEvent

CLmkDlgCombiSelectorImpl::HandleFilteredLmSelectorStateEventL(

    TLmkSelectorStateEvent aEvent )

    {

    __ASSERT_DEBUG( aEvent == ELmkSelectorStop,

                    Panic( KLmkPanicUnexpectedEvent ) );

    // filtered lm selector shouldn't be removed earlier

    CLmkDlgSelectorImplBase*& selector = iSelectors[ELmkFilteredLmSelector];

    delete selector;

    selector = NULL; // iSelector's pointer points to NULL now!

    //Restore navi panel

    iLmkUiUtils->RestoreOldNaviPaneL();

    if ( aEvent == ELmkSelectorStop && iDlgRetVal != 0 )

        {

        iSelectorState = ELmkFinalState;

        return ELmkSelectorNoEvent;

        }

    else // aEvent == ELmkSelectorStop & dialog canceled

        {

        iSelectorState = ELmkCategorySelector;

        CLmkDlgSelectorImplBase& dlgselector = CurrentStateSelectorL();

        TInt categoryIndex( -1 );

        iDlgRetVal = dlgselector.ExecuteL( categoryIndex );

        iCategoryIndex = categoryIndex;

        return ELmkSelectorStop;

        }

    }

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

// CLmkDlgCombiSelectorImpl::HandleDefaultStateStateEventL

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

//

CLmkDlgCombiSelectorImpl::TLmkSelectorStateEvent

CLmkDlgCombiSelectorImpl::HandleDefaultStateStateEventL(

    TLmkSelectorStateEvent /*aEvent*/ )

    {

    return ELmkSelectorNoEvent;

    }

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

// CLmkDlgCombiSelectorImpl::SetupListProviderL

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

//

void CLmkDlgCombiSelectorImpl::SetupListProviderL()

    {

    // This class does not create own provider

    }

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

// CLmkDlgCombiSelectorImpl::ListProvider

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

//

const CLmkListProviderBase& CLmkDlgCombiSelectorImpl::ListProvider() const

    {

    if ( iSelectorState ==  ELmkCategorySelector )

        {

        return iSelectors[ELmkCategorySelector]->ListProvider();

        }

    else if ( iSelectorState ==  ELmkFilteredLmSelector )

        {

        return iSelectors[ELmkFilteredLmSelector]->ListProvider();

        }

    else // ELmkLandmarkSelector

        {

        return iSelectors[ELmkLandmarkSelector]->ListProvider();

        }

    }

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

// CLmkDlgCombiSelectorImpl::GetDlgResources

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

//

void CLmkDlgCombiSelectorImpl::GetDlgResources(

    TBool /*aIsSingleSelector*/,

    TInt& aTitlePaneResource,

    TInt& aMenuBarResource,

    TInt& aDialogResource ) const

    {

    // This class does not define resources

    aTitlePaneResource = NULL;

    aMenuBarResource = NULL;

    aDialogResource = NULL;

    }

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

// CLmkDlgCombiSelectorImpl::StoreMemento

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

//

void CLmkDlgCombiSelectorImpl::StoreMemento()

    {

    // This class does not store

    }

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

// CLmkDlgCombiSelectorImpl::RestoreMemento

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

//

void CLmkDlgCombiSelectorImpl::RestoreMemento()

    {

    // This class does not restore

    }

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

// CLmkDlgCombiSelectorImpl::ProcessCommandL

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

//

void CLmkDlgCombiSelectorImpl::ProcessCommandL( TInt /*aCommandId*/ )

    {

    // This class does not process cmds

    }