/*

 * Copyright (c) 2002-2010 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 methods implementing the core

 *                functionality of landmarks editor

 *

 */

// INCLUDE FILES

#include <AknSettingCache.h>

#include <AiwServiceHandler.h>      // AIW

#include <AiwCommon.hrh>            // AIW

#include <featmgr.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <aknmessagequerydialog.h>

#include <AknIconUtils.h>

#include <AknWaitDialog.h>

#include <aknlists.h>

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <eikcapc.h>

#include <eikmenup.h>

#include <hlplch.h>

#include <sendnorm.rsg> // R_SENDUI_MENU

#include <lmkui.rsg>

#include <CLmkEditorDlg.h>

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLandmarkDatabase.h>

#include <epos_poslandmarkserialization.h>

#include <bldvariant.hrh>

#include <AknDef.h>

#include <sysutil.h>

#include <baclipb.h>                        // for CClipboard

#include <txtrich.h>

#include <txtetext.h>

#include <s32std.h>

#include "CLmkUiUtils.h"

#include "landmarks.hrh"

#include "LmkConsts.h"

#include "LmkUID.h"

#include "CLmkLocationService.h"

#include "CLmkDbUtils.h"

#include "CLmkEditorFieldArray.h"

#include "MLmkEditorField.h"

#include "LmkNotes.h"

#include "CLmkDlgCategorySelectorImpl.h"

#include <csxhelp/lm.hlp.hrh>

#include "CLmkSender.h"

#include "clmkgotourlcmd.h"

#include "clmkcallcmd.h"

#include "CLmkEditorImpl.h"

#include "CLmkEditorTextField.h"

#include "lmkicondialog.h"

#include "CLmkEditorListField.h"

#include "CLmkEditorCoordinateField.h"

#include <Landmarks.rsg>

#include <uriutils.h>

#include "LmkListProviderFactory.h"

#include "CLmkListProviderBase.h"

#include <locnotprefplugindomaincrkeys.h>

#include "clmkcentralrepository.h"

#include "CLmkEditorNumberField.h"

#include "lmkwaitdlglauncher.h" // Wait dialog launcher

#include "LmkEditorFieldFactory.h"

#include <locationvariationdomaincrkeys.h>

#include <lmkerrors.h>

#include "Debug.h"

// CONSTANTS

/// Unnamed namespace for local definitions

namespace

    {

    const TInt KHOffsetCatInfoPopup(100);

    const TInt KVOffsetCatInfoPopup(30);

#if defined(_DEBUG)

    _LIT( KPanicMsg, "CLmkEditorImpl");

    void Panic(TPanicCode aReason)

        {

        User::Panic(KPanicMsg, aReason);

        }

#endif

    } // namespace

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

static void CleanupArray(TAny* aArray)

    {

    (static_cast<RPointerArray<CPosLandmark>*> (aArray))->ResetAndDestroy();

    }

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

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

// CLmkEditorImpl::CLmkEditorImpl

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

// might leave.

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

//

CLmkEditorImpl::CLmkEditorImpl(CPosLandmarkDatabase& aDb,

        CLmkSender& aSender, TLmkEditorMode aEditorMode) :

    iDb(aDb), iSender(aSender), iEditorMode(aEditorMode), iIsEditing(EFalse),

            iResetWebAddrSize(ETrue), iIsCategorySelctorOpen(EFalse)

    {

    }

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

// CLmkEditorImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkEditorImpl::ConstructL(TPosLmItemId aLandmarkId,

        TLmkEditorAttributes aAttributes)

    {

    DEBUG( CLmkEditorImpl::ConstructL Editing/Viewing Existing Landmark with LandmarkId )

    CommonConstructL(aAttributes);

    iLandmark = iDb.ReadLandmarkLC(aLandmarkId);

    iLmkFields = CLmkFields::NewL(iLabelArray, iDb, aAttributes, aLandmarkId,

            iLandmark, iJapaneseInputMode);

    ChangeContextImageL();

    iEditorFieldArray = CLmkEditorFieldArray::NewL(*iLmkFields, *this);

    CleanupStack::Pop(iLandmark);

    if (iLandmark)

        {

        iIsLmOwned = ETrue;

        }

    iListProvider = LmkListProviderFactory::CreateProviderL( iDb, ELandmarkSelector );

    iListProvider->AddObserverL( *this );

    iListProvider->InitializeL();    

    }

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

// CLmkEditorImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkEditorImpl::ConstructL(CPosLandmark* aLandmark,

        TLmkEditorAttributes aAttributes)

    {

    DEBUG( CLmkEditorImpl::ConstructL Editing/Viewing Existing Landmark with Landmark Object );

    CommonConstructL(aAttributes);

    iLmkFields = CLmkFields::NewL(iLabelArray, iDb, aAttributes,

            aLandmark->LandmarkId(), aLandmark, iJapaneseInputMode);

    iLandmark = aLandmark;

    ChangeContextImageL();

    iEditorFieldArray = CLmkEditorFieldArray::NewL(*iLmkFields, *this);

    }

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

// CLmkEditorImpl::ConstructL

// Symbian 2nd phase constructor can leave.

// Empty Landmark Editor

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

//

void CLmkEditorImpl::ConstructL(TPosLmItemId* aLandmarkId,

        CPosLandmark* aLandmark, TLmkEditorAttributes aAttributes)

    {

    DEBUG( CLmkEditorImpl::ConstructL Empty Landmarks Editor Construction );

    CommonConstructL(aAttributes);

    iLmkFields = CLmkFields::NewL(iLabelArray, iDb, aAttributes,

            *aLandmarkId, aLandmark, iJapaneseInputMode);

    iLandmarkItemId = aLandmarkId;

    iLandmark = aLandmark;

    ChangeContextImageL();

    iEditorFieldArray = CLmkEditorFieldArray::NewL(*iLmkFields, *this);

    }

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

// CLmkEditorImpl::CommonConstructL

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

//

void CLmkEditorImpl::CommonConstructL(TLmkEditorAttributes& aAttributes)

    {

    DEBUG( CLmkEditorImpl::CommonConstructL Start )

    iLandmarkItemId = NULL; // Set to NULL by default. Use only where needed.

    iLmkUiUtils = CLmkUiUtils::NewL();

    iLmkUiUtils->ReadLmkUiResourceFileL();

    CAknForm::ConstructL(R_LMK_EDITOR_MENUBAR);

    iLmkUiUtils->StoreNaviPaneL(); // store old navi pane

    iLmkUiUtils->CreateDefaultNaviPaneL();

    // For setting Japanese input mode

    CAknSettingCache& cache = CAknEnv::Static()->SettingCache();

    TLanguage currentLanguage = cache.InputLanguage();

    if (currentLanguage == ELangJapanese)

        {

        iJapaneseInputMode = ETrue;

        }

    else

        {

        iJapaneseInputMode = EFalse;

        }

    CreateLabelArrayL();

    ConstructContextMenuL();

    // launching browser

    iLmkGoToURLCmd = CLmkGoToURLCmd::NewL();

    // Launching Call UI

    iLmkCallCmd = CLmkCallCmd::NewL();

    iLmkCallCmd->AttachMenuPaneL(R_LMK_EDITOR_CALL_SUBMENU,

            R_LMK_EDITOR_AIW_INTEREST);

    // Create AIW interest

    iLmkCallCmd->AttachInterestL(R_LMK_EDITOR_AIW_INTEREST);

    // By default enable map and navigation feature

    iMapNavFeature = ETrue;

    iMapNavInterface = CLmkMapNavigationInterface::NewL(iDb);

    iCatInfoPopupNote = NULL;

    iRepository = CLmkCentralRepository::NewL(KLocSystemofMeasurements, this);

    // Create the wait dialog launcher

    iWaitDialogLauncher = CLmkWaitDialogLauncher::NewL();

    iWaitDialogLauncher->SetObserver(this);

    iIsLmOwned = EFalse;

    // Check if the Coordinates has to be hidden

    CheckHideCoordinateL();

    if (iIsHideCoordinate)

        {

        aAttributes &= ~CLmkEditorDlg::ELmkLatitude;

        aAttributes &= ~CLmkEditorDlg::ELmkLongitude;

        aAttributes &= ~CLmkEditorDlg::ELmkPositionAccuracy;

        aAttributes &= ~CLmkEditorDlg::ELmkAltitude;

        aAttributes &= ~CLmkEditorDlg::ELmkAltitudeAccuracy;

        }

    DEBUG( CLmkEditorImpl::CommonConstructL End )

    }

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

// CLmkEditorImpl::NewL

// Two-phased constructor.

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

//

EXPORT_C CLmkEditorImpl* CLmkEditorImpl::NewL(CPosLandmarkDatabase& aDb,

        CLmkSender& aSender, TLmkEditorAttributes aAttributes,

        TLmkEditorMode aEditorMode, TPosLmItemId aLandmarkId)

    {

    CLmkEditorImpl* self = new (ELeave) CLmkEditorImpl(aDb, aSender,

            aEditorMode);

    CleanupStack::PushL(self);

    self->ConstructL(aLandmarkId, aAttributes);

    CleanupStack::Pop(); //self

    return self;

    }

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

// CLmkEditorImpl::NewL

// Two-phased constructor.

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

//

EXPORT_C CLmkEditorImpl* CLmkEditorImpl::NewL(CPosLandmarkDatabase& aDb,

        CLmkSender& aSender, TLmkEditorAttributes aAttributes,

        TLmkEditorMode aEditorMode, CPosLandmark* aLandmark)

    {

    CLmkEditorImpl* self = new (ELeave) CLmkEditorImpl(aDb, aSender,

            aEditorMode);

    CleanupStack::PushL(self);

    self->ConstructL(aLandmark, aAttributes);

    CleanupStack::Pop(); //self

    return self;

    }

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

// CLmkEditorImpl::NewL

// Two-phased constructor.

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

//

EXPORT_C CLmkEditorImpl* CLmkEditorImpl::NewL(CPosLandmarkDatabase& aDb,

        CLmkSender& aSender, TLmkEditorAttributes aAttributes,

        TLmkEditorMode aEditorMode, TPosLmItemId* aLandmarkId,

        CPosLandmark* aLandmark)

    {

    CLmkEditorImpl* self = new (ELeave) CLmkEditorImpl(aDb, aSender,

            aEditorMode);

    CleanupStack::PushL(self);

    self->ConstructL(aLandmarkId, aLandmark, aAttributes);

    CleanupStack::Pop(); //self

    return self;

    }

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

// CLmkEditorImpl::~CLmkEditorImpl()

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

//

CLmkEditorImpl::~CLmkEditorImpl()

    {

    delete iWaitDialogLauncher;

    CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();

    cba->RemoveCommandObserver(KMskCommandPos);

    if (iLmkUiUtils)

        {

        iLmkUiUtils->SetOldContextIcon();

        iLmkUiUtils->RestoreOldTitlePane();

        }

    delete iLmkUiUtils;

    delete iLmkFields;

    iLabelArray.ResetAndDestroy();

    iCategoryNames.Close();

    iLabelArray.Close();

    delete iEditorFieldArray;

    delete iLocationService;

    if (iContextMenuBar)

        {

        iEikonEnv->EikAppUi()->RemoveFromStack(iContextMenuBar);

        delete iContextMenuBar;

        }

    delete iLmkGoToURLCmd;

    delete iLmkCallCmd;

    iMapNavInterface->Release();

    delete iCatInfoPopupNote;

    if(iListProvider)

        {

        iListProvider->RemoveObserver(*this);

        delete iListProvider;

        }    

    delete iRepository;

    if (iIsLmOwned && iLandmark)

        delete iLandmark;

    }

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

// CLmkEditorImpl::SetMopParent

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

//

EXPORT_C void CLmkEditorImpl::SetMopParent(MObjectProvider* aParent)

    {

    CCoeControl::SetMopParent(aParent);

    }

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

// CLmkEditorImpl::SetHelpContext

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

//

EXPORT_C void CLmkEditorImpl::SetHelpContext(TCoeHelpContext aContext)

    {

    iHelpContext = aContext;

    }

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

// CLmkEditorImpl::ExecuteL

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

//

EXPORT_C TInt CLmkEditorImpl::ExecuteLD()

    {

    CleanupStack::PushL(this);

    AttachAIWMenuInterestL();

    CleanupStack::Pop();//this

    if (iEditorMode == CLmkEditorDlg::ELmkEditor)

        {

        iIsEditing = ETrue;

        return CAknForm::ExecuteLD(R_LMK_EDITOR_DIALOG);

        }

    else // viewer/receive state of editor

        {

        iIsEditing = EFalse;

        return CAknForm::ExecuteLD(R_LMK_VIEWER_DIALOG);

        }

    }

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

// CLmkEditorImpl::DisableMapAndNavigationMenuOptions

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

//

EXPORT_C void CLmkEditorImpl::DisableMapAndNavigationMenuOptions()

    {

    iMapNavFeature = EFalse;

    }

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

// CLmkEditorImpl::DynInitMenuPaneL

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

//

void CLmkEditorImpl::DynInitMenuPaneL(TInt aResourceId,

        CEikMenuPane* aMenuPane)

    {

    switch (aResourceId)

        {

        case R_AVKON_FORM_MENUPANE:

            {

            CAknForm::DynInitMenuPaneL(aResourceId, aMenuPane);

            TBool isLandmarkDataEmpty = EFalse;

            TBool dimClearPos = ETrue;

            // Disable Map and Navigation feature when opted not to show    

            if (!iMapNavFeature)

                {

                isLandmarkDataEmpty = ETrue;

                }

            else if (iLandmark && iIsHideCoordinate)

                {

                isLandmarkDataEmpty = IsLandmarkDataEmptyL(iLandmark);

                }

            else

                {

                isLandmarkDataEmpty = ArePositionFieldEmptyL();

                }

            if (isLandmarkDataEmpty)

                {

                // delete the show on map & Navigate To options

                aMenuPane->DeleteMenuItem(ELmkShowOnMapPlaceHolder);

                aMenuPane->DeleteMenuItem(ELmkNavigateToPlaceHolder);

                }

            else if (IsEditable())

                {

                // delete the Navigate To option for editor

                aMenuPane->DeleteMenuItem(ELmkNavigateToPlaceHolder);

                }

            if (IsEditable())

                {

                dimClearPos = ArePositionFieldEmptyL();

                }

            if (dimClearPos || iIsHideCoordinate)

                {

                aMenuPane->SetItemDimmed(ELmkCmdClearPosInfo, ETrue);

                }

            if (iMapNavFeature)

                {

                iMapNavInterface->AttachMenuPaneL(aMenuPane,

                        R_LMK_EDITOR_MENU, ELmkCmdMnNav);

                }

            // Send menu is handled by the sender:

            if (FeatureManager::FeatureSupported(KFeatureIdLandmarksConverter))

                {

                aMenuPane->SetItemDimmed(ELmkCmdSendDummy, EFalse);

                iSender.DisplaySendMenuL(*aMenuPane, 1);

                }

            else

                {

                aMenuPane->SetItemDimmed(ELmkCmdSendDummy, ETrue);

                }

            if (FeatureManager::FeatureSupported(

                    KFeatureIdLocationFrameworkCore))

                {

                aMenuPane->SetItemDimmed(ELmkCmdCurrentLocation,

                        !IsEditable());

                }

            else

                {

                aMenuPane->SetItemDimmed(ELmkCmdCurrentLocation, ETrue);

                }

            if (FeatureManager::FeatureSupported(KFeatureIdHelp)

                    && !iIsHideHelp)

                {

                aMenuPane->SetItemDimmed(EAknCmdHelp, EFalse);

                }

            else

                {

                aMenuPane->SetItemDimmed(EAknCmdHelp, ETrue);

                }

            //only in edit mode

            aMenuPane->SetItemDimmed(ELmkCmdSelectCategories, !IsEditable());

            aMenuPane->SetItemDimmed(ELmkCmdChangeIcon, !IsEditable());

            //additional commands always dimmed in this class:

            aMenuPane->SetItemDimmed(ELmkCmdSaveLm, ETrue);

            // Only in view mode

            aMenuPane->SetItemDimmed(ELmkCmdEditLm, IsEditable());

            //allways dimmed

            aMenuPane->SetItemDimmed(EAknFormCmdEdit, ETrue);

            aMenuPane->SetItemDimmed(EAknFormCmdSave, ETrue);

            aMenuPane->SetItemDimmed(EAknFormCmdLabel, ETrue);

            aMenuPane->SetItemDimmed(EAknFormCmdAdd, ETrue);

            aMenuPane->SetItemDimmed(EAknFormCmdDelete, ETrue);

            aMenuPane->SetItemDimmed(ELmkCmdCategories, ETrue);

            aMenuPane->SetItemDimmed(ELmkCmdEditTextLm, ETrue);

            if (IsEditable())

                {

                aMenuPane->SetItemDimmed(ELmkCmdCall, ETrue);

                aMenuPane->SetItemDimmed(ELmkCmdGoToUrl, ETrue);

                }

            else

                {