/*

* Copyright (c) 2002-2006 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:  This file contains the selector implementation for landmarks by

*               name view

*

*/

// INCLUDE FILES

#include <AiwServiceHandler.h>      // AIW

#include <AiwCommon.hrh>            // AIW

#include <lbsfields.h>

#include <aknsfld.h>

#include <aknlists.h>

#include <StringLoader.h>

#include <EPos_CPosLmCategoryCriteria.h>

#include <EPos_CPosLmCategoryManager.h>

#include <AknWaitDialog.h>

#include <lmkui.rsg>

#include <Landmarks.rsg>

#include <CLmkEditorDlg.h> // from system include!

#include "clmkdbsearchutils.h"

#include "LmkConsts.h"

#include "landmarks.hrh"

#include "CLmkDbUtils.h"

#include "CLmkFields.h"

#include "CLmkUiUtils.h"

#include "CLmkEditorImpl.h"

#include "LmkNotes.h"

#include "CLmkSender.h"

#include "LmkListProviderFactory.h"

#include "CLmkLmItemListProvider.h"

#include "CLmkDlgCategorySelectorImpl.h"

#include "CLmkLmItemListMemento.h"

#include "clmkgotourlcmd.h"

#include "CLmkAppLmSelectorImpl.h"

#include "MLmkMapAndNavigationObServer.h"

#include "CLmkAOOperation.h"

#include "MLmkMskObserver.h"

#include "CLmkLocSettingLauncher.h"

#include <lmkerrors.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

//Below three flags are used only for category remove operation.

//This one is used, when the remove operation starts

const TInt KRemoveOperationStarted(2);

//This one is used when, remove operation ends.

const TInt KRemoveOperationCompleted(4);

//This one is used, when the remove operation ends & the list box model

//also is updated, after getting an event from database.

const TInt KRremoveListBoxModUpdated(8);

#if defined(_DEBUG)

_LIT( KPanicMsg, "CLmkAppLmSelectorImpl" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

#endif

}  // namespace

_LIT(KWildCard, "*");

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

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

// CLmkAppLmSelectorImpl::CLmkAppLmSelectorImpl

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

// might leave.

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

//

CLmkAppLmSelectorImpl::CLmkAppLmSelectorImpl(

    CPosLandmarkDatabase& aDb,

    CLmkSender& aSender,

    TBool aFindBox )

    : CLmkAppLmItemSelectorImpl( aDb, aSender, aFindBox ),iIsDlgOpen(EFalse)

    {

    }

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

// CLmkAppLmSelectorImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkAppLmSelectorImpl::ConstructL()

    {

    CLmkAppLmItemSelectorImpl::BaseConstructL();

    // Added for rel 3.1

    iLmkCallCmd = CLmkCallCmd::NewL();

    iDbSearchUtils = NULL;

    // launching browser

    iLmkGoToURLCmd = CLmkGoToURLCmd::NewL();

    }

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

// CLmkAppLmSelectorImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkAppLmSelectorImpl::ConstructL(

    const MLmkListMemento& aCategoryMemento )

	{

	// Listing contents of current category is implemented using category

	// view's memento:

	const CLmkLmItemListMemento& categoryMemento =

	static_cast<const CLmkLmItemListMemento&>( aCategoryMemento );

	TPosLmItemId categoryId = categoryMemento.MemorizedItemId();

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

		{

		// set criteria for searchnig 'Uncategorised' landmarks

		iCategoryName = StringLoader::LoadL(

		    R_LMK_LM_LIST_UNCATEGORISED, const_cast<CEikonEnv *>( iEnv ));

		}

	else

		{

		// Construction must fail if category has been deleted:

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

		CleanupStack::PushL( mgr );

		// Leaves with KErrNotFound if category doesn't exist

		CPosLandmarkCategory* category = mgr->ReadCategoryLC( categoryId );

		TPtrC categoryName;

		User::LeaveIfError(category->GetCategoryName(categoryName));

		iCategoryName = categoryName.AllocL();

		CleanupStack::PopAndDestroy( 2 ); // category, mgr

		}

	iCriteria = CPosLmCategoryCriteria::NewLC();

	CleanupStack::Pop(); // iCriteria

	iCriteria->SetCategoryItemId( categoryId );

    iMarkedCatCountAdded = 0;

	// Call "normal" ConstructL():

	ConstructL();

	}

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

// CLmkAppLmSelectorImpl::NewL

// Two-phased constructor.

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

//

EXPORT_C CLmkAppLmSelectorImpl* CLmkAppLmSelectorImpl::NewL(

    CPosLandmarkDatabase& aDb,

    CLmkSender& aSender,

    TBool aFindBox )

    {

    CLmkAppLmSelectorImpl* self =

        new( ELeave ) CLmkAppLmSelectorImpl( aDb, aSender, aFindBox );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CLmkAppLmSelectorImpl::NewL

// Two-phased constructor.

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

//

EXPORT_C CLmkAppLmSelectorImpl* CLmkAppLmSelectorImpl::NewL(

    CPosLandmarkDatabase& aDb,

    const MLmkListMemento& aCategoryMemento,

    CLmkSender& aSender,

    TBool aFindBox )

    {

    CLmkAppLmSelectorImpl* self =

        new( ELeave ) CLmkAppLmSelectorImpl( aDb, aSender, aFindBox );

    CleanupStack::PushL( self );

    self->ConstructL( aCategoryMemento );

    CleanupStack::Pop();

    return self;

    }

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

// CLmkAppLmSelectorImpl::~CLmkAppLmSelectorImpl

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

//

CLmkAppLmSelectorImpl::~CLmkAppLmSelectorImpl()

    {

    delete iCriteria;

    delete iCategoryName;

    delete iLmkCallCmd;

    delete iDbSearchUtils;

    delete iLmkGoToURLCmd;

    }

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

// CLmkAppLmSelectorImpl::CategoryNameL

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

//

EXPORT_C TPtrC CLmkAppLmSelectorImpl::CategoryNameL()

    {

    return *iCategoryName;

    }

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

// CLmkAppLmSelectorImpl::SetupListProviderL

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

//

void CLmkAppLmSelectorImpl::SetupListProviderL()

    {

    if ( !iListProvider )

        {

        if ( iCriteria )

            {

            iListProvider =

                LmkListProviderFactory::CreateProviderL( iDb, *iCriteria );

            }

        else

            {

            iListProvider =

                LmkListProviderFactory::CreateProviderL( iDb,

                                                         ELandmarkSelector );

            }

        iListProvider->AddObserverL( *this );

        iListProvider->InitializeL();

        }

    }

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

// CLmkAppLmSelectorImpl::ListProvider

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

//

const CLmkListProviderBase& CLmkAppLmSelectorImpl::ListProvider() const

    {

    __ASSERT_DEBUG( iListProvider, Panic( KLmkPanicNullMember ) );

    return *iListProvider;

    }

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

// CLmkAppLmSelectorImpl::HandleCategorySearchNotifyL

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

//

void CLmkAppLmSelectorImpl::HandleCategorySearchNotifyL(RArray<TPosLmItemId> /*aArray*/)

	{

	// This search is not used

	}

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

// CLmkAppLmSelectorImpl::HandleLmkSearchNotifyL

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

//

void CLmkAppLmSelectorImpl::HandleLmkSearchNotifyL()

	{

	iWaitNote->ProcessFinishedL();

	}

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

// CLmkAppLmSelectorImpl::ProcessCommandL

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

//

void CLmkAppLmSelectorImpl::ProcessCommandL( TInt aCommandId )

    {

    __ASSERT_DEBUG( iListProvider, Panic( KLmkPanicNullMember ) );

    switch ( aCommandId )

        {

        case ELmkCmdEditLm:

            {

            if( iIsDlgOpen )

            	break;

          	EditLandmarkCmdL(CLmkEditorDlg::ELmkEditor);

  					iSearchBox->ResetL();

            break;

            }

        case ELmkCmdOpenLm:

            {

            if( iIsDlgOpen )

            	break;

            EditLandmarkCmdL(CLmkEditorDlg::ELmkViewer);

    		iSearchBox->ResetL();

    	#ifdef RD_SCALABLE_UI_V2

    		iSearchBox->DrawDeferred();

        #endif// RD_SCALABLE_UI_V2

       		iListProvider->StartSearchingLandmarksL(KWildCard, EFalse);

            break;

            }

        case ELmkCmdGoToUrl:

            {

			HBufC* lmkUrl = HBufC::NewL( KMaxBufferLen );

			CleanupStack::PushL( lmkUrl );

			if (GetPositionFieldForSelectedLmL(

							ELmkPositionFieldWebAddress,

							*lmkUrl ) == KErrNone)

				{

				if ( lmkUrl->Length() > 0 )

					{

					// Get the URL of the LM and launch browser

					iLmkGoToURLCmd->LaunchBrowserL( *lmkUrl );

					}

				}

			CleanupStack::PopAndDestroy( lmkUrl );

			break;

            }

        case ELmkCmdCall:

	        {

			// Create AIW interest

	        ExecuteAIWCallCmdL( aCommandId );

	        break;

	        }

        case ELmkCmdDeleteLm:

            {

            DeleteLandmarksCmdL();

            break;

            }

		case ELmkCmdChangeIcon:

			{

            ChangeIconCmdL();

			break;

			}

        case ELmkCmdAddToCat:

            {

            AddToCatCmdL();

            break;

            }

        case ELmkCmdSendVia1:

        case ELmkCmdSendVia2:

        case ELmkCmdSendVia3:

        case ELmkCmdSendVia4:

        case ELmkCmdSendVia5:

        case ELmkCmdSendVia6:

        case ELmkCmdSendVia7:

        case ELmkCmdSendVia8:

        case ELmkCmdSendVia9:

        case ELmkCmdSendVia10:

        case ELmkCmdSend:

            {

            RArray<TPosLmItemId>& markedIds = MarkedItemIdsL();

            if(markedIds.Count() == 0)

            	{

            	CPosLandmark* landmark = iDb.ReadLandmarkLC(SelectedIdL());

            	iSender.SendSingleLandmarkL(*landmark);

            	CleanupStack::PopAndDestroy();//landmark

            	}

            else

            	{

            	//Send multiple landmarks

           		TPtrC ptr;

	        	RPointerArray<CLmkLandmark> lmkArray;

	        	TRAPD( sendErr, iSender.PrepareMultipleLandmarkForSendL(lmkArray,markedIds) );

	        	if(sendErr == KErrNone)

	        		{

	        		TRAP( sendErr, iSender.SendLandmarksL(aCommandId,ptr,lmkArray) );

	        		}

	        	lmkArray.ResetAndDestroy();

	        	if(sendErr == KErrNoMemory)

	        		{

	        		User::LeaveNoMemory();

	        		}

            	}

            break;

            }

        case EAknCmdMark:

        case EAknCmdUnmark:

        case EAknMarkAll:

        case EAknUnmarkAll:

	        {

	        if(iMskObserver)

				{

				iMskObserver->UpdateMskContainerL();

				}

			break;

	        }

		case ELmkCmdLaunchPositionSettings:

			{

			LaunchPosSettingsL();

			break;

			}

        case ELmkCmdFindBoxSearchAfresh:

        case ELmkCmdFindBoxSearchInPreviousResults:

        	{

			TInt searchTextLength = iSearchBox->TextLength();

		    const TInt KExtraChars = 2; // 2 chars wildcards

		    HBufC* filterBuf = HBufC::NewLC(searchTextLength + KExtraChars);

		    TPtr filter = filterBuf->Des();

		    iSearchBox->GetSearchText(filter);

	        filter.Append(KWildCard);

	        iListProvider->StartSearchingLandmarksL(filter, EFalse);

            CleanupStack::PopAndDestroy( filterBuf );

	        break;

        	}

        default:

            {

            CLmkAppLmItemSelectorImpl::ProcessCommandL( aCommandId );

            break;

            }

        }

    }

EXPORT_C void CLmkAppLmSelectorImpl::StartSearchingLandmarksL(

								const TDesC& /*aSearchPattern*/,

    							TBool /*aSearchOnlyInPreviousMatches*/)

	{

	iListProvider->InitializeL();

	}

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

// CLmkAppLmSelectorImpl::HandleOperationL

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

//

void CLmkAppLmSelectorImpl::HandleOperationL(

                                       TOperationTypes aType,

                                       TReal32 /*aProgress*/,

                                       TInt aStatus )

    {

    TBool deleteNote = EFalse;

    switch (aType)

        {

         case EDeleteLandmarks:

             {

             if (aStatus != KPosLmOperationNotComplete)

                 {

                 deleteNote = ETrue;

                 }

             }

         break;

         case EAddToCategory:

             {

             if (iMarkedCatCountAdded ==1)

                 {

                 deleteNote = ETrue;

                 }

              else if (iMarkedCatCountAdded > 1)

                 {

                 --iMarkedCatCountAdded;

                 }

             }

         break;

        case ERemoveCategory:

        	{

        	if (iOperation && aStatus != KPosLmOperationNotComplete)

	        	{

		        if((iCatRemoveFlag & KRremoveListBoxModUpdated) &&

		           (iCatRemoveFlag & KRemoveOperationStarted )&& iWaitNote)

					{

					//Since the operation is completed and listbox model

					//is updated first, wait note can be closed now

					CloseWaitNoteL();

			        iListBox->SetCurrentItemIndex(0);

			        //nullify all the flags

			        iCatRemoveFlag &= ~KRemoveOperationCompleted;

			        iCatRemoveFlag &= ~KRremoveListBoxModUpdated;

			        iCatRemoveFlag &= ~KRemoveOperationStarted;

					}

				else

					{

					//operation completed but cannot close the wait dialog

					//since, the listbox model is not updated.Now , it will

					//be closed in HandleEventListReadyL function.Set the operation

					//completion flag

					iCatRemoveFlag |= KRemoveOperationCompleted;

					}

				}

    	   	}

         break;

         default:

         break;

        }

    if (deleteNote && iWaitNote)

        {

        iWaitNote->ProcessFinishedL();

        iWaitNote = NULL;

        }

    }

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

// CLmkAppLmSelectorImpl::ChangeIconL

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

//

void CLmkAppLmSelectorImpl::ChangeIconL(

    TPosLmItemId aId,

    TInt aIconIndex,

    TInt aMaskIndex)

    {

    TFileName* iconFile = CLmkUiUtils::LmkUiIconFileLC();

    iDbUtils->ChangeIconL( iDb, aId, ELmkItemTypeLandmark,

                           *iconFile, aIconIndex, aMaskIndex);

    CleanupStack::PopAndDestroy();//iconFile

    }

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

// CLmkAppLmSelectorImpl::ChangeIconsL

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

//

void CLmkAppLmSelectorImpl::ChangeIconsL(

    RArray<TPosLmItemId>& aIdArray,

    TInt aIconIndex,

    TInt aMaskIndex)

    {

    TFileName* iconFile = CLmkUiUtils::LmkUiIconFileLC();

    iDbUtils->ChangeIconsL( aIdArray, ELmkItemTypeLandmark,

                            *iconFile, aIconIndex, aMaskIndex);

	CleanupStack::PopAndDestroy();//iconFile

    }

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

// CLmkAppLmSelectorImpl::InitialLandmarkL

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

//

void CLmkAppLmSelectorImpl::InitialLandmarkL( CPosLandmark* aLandmark )