/*

* Copyright (c) 2009 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 : Class description for unified editor

*

*/

// user includes

#include "calenunifiededitor.h"

#include "CalenDefaultEditors.hrh"

#include "calenglobaldata.h"

#include "calenunifiededitorcontrol.h"

#include "calendbfield.h"

#include "calenlocationutil.h"

#include "CalenEntryUpdater.h"

#include "CalenEditorDataHandler.h"

#include "calenentryutil.h"

#include "calensend.h"

#include "CalenDescription.h"

#include "calenattachmentinfo.h"

#include "calenattachmentmodel.h"

#include "CleanupResetAndDestroy.h"

#include "CalendarPrivateCRKeys.h"

// system includes

#include <coemain.h>

#include <eikdialg.h>

#include <bacntf.h>

#include <eikspane.h>

#include <akntitle.h>

#include <aknnavi.h>

#include <eikcapc.h>

#include <StringLoader.h>

#include <featmgr.h>

#include <hlplch.h>

#include <AknQueryDialog.h>

#include <AknUtils.h>

#include <AknIconUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <eikrted.h>

#include <txtrich.h>

#include <aknnotewrappers.h>

#include <sysutil.h>

#include <ErrorUI.h>

#include <EPos_CPosLandmark.h>

#include <lbsposition.h>

#include <calentry.h>

#include <CalenDefaultEditorsData.rsg>

#include <Calendar.rsg>

#include <calenagendautils.h> // Need to conform the access.

#include <calrrule.h>

#include <calendateutils.h>

#include <CalenInterimUtils2.h>

#include <centralrepository.h>

#include <calencommands.hrh>            // Calendar commands

#include <calencontext.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include <calenservices.h>

#include <calcalendarinfo.h>

// debug

#include "calendarui_debug.h"

const TInt KCalenMaxELAFTextEditorLength(160);

const TInt KCalenMaxAPACTextEditorLength(70);

// Custom id for command to close form without any checks.

// We need just to close form without saving, when entry is deleted from options menu

const TInt KCalenButtonIdCloseForm(-400);

_LIT(KComma, ",");

_LIT(KEmpty,"");

_LIT(KAttachmentSeparator,"; ");

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

// CCalenUnifiedEditor::NewL

// Two-phased constructor.

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

//  

CCalenUnifiedEditor* CCalenUnifiedEditor::NewL( CCalEntry& aEntry,

                                                const TAgnEntryUiInParams& aParams,

                                                MAgnEntryUiCallback& aCallback,

                                                TAgnEntryUiOutParams& aOutParams,

                                                CalCommon::TRecurrenceRange aRepeatType)

    {

    TRACE_ENTRY_POINT;

    CCalenUnifiedEditor* self = 

        new (ELeave) CCalenUnifiedEditor( aEntry, aParams, aCallback, aOutParams, aRepeatType );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenUnifiedEditor::NewL

// Two-phased constructor.

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

//

CCalenUnifiedEditor* CCalenUnifiedEditor::NewL( CCalEntry& aEntry,

                                                const TAgnEntryUiInParams& aParams,

                                                MAgnEntryUiCallback& aCallback,

                                                TAgnEntryUiOutParams& aOutParams )

    {

    TRACE_ENTRY_POINT;

    CCalenUnifiedEditor* self = 

        new (ELeave) CCalenUnifiedEditor( aEntry, aParams, aCallback, aOutParams );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenUnifiedEditor::~CCalenUnifiedEditor

// Destructor

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

//

CCalenUnifiedEditor::~CCalenUnifiedEditor()

    {

    TRACE_ENTRY_POINT;

    if( iGlobalData )

        {

        iGlobalData->Release();

        }

    // Remove default status pane

    if( iNaviContainer )

        {

        iNaviContainer->Pop();

        iNaviContainer = NULL;

        }

    if( iIdle )

        {

        delete iIdle;

        }

    iCoeEnv->RemoveFepObserver( *this );

    if( iServices )

        {

        iServices->CancelNotifications( this );

        }

    delete iLocaleChangeNotifier;

    delete iOriginalCalEntry;

    delete iEditorDataHandler;

    delete iEntryUpdater;

    delete iUnifiedEditorControl;

    iCollectionIds.Reset();

    iAsyncCallback->Cancel();

    delete iAsyncCallback;

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditor::CCalenUnifiedEditor

// Default constructor

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

//

CCalenUnifiedEditor::CCalenUnifiedEditor( CCalEntry& aEntry,

                     const TAgnEntryUiInParams& aParams,

                     MAgnEntryUiCallback& aCallback,

                     TAgnEntryUiOutParams& aOutParams,

                     CalCommon::TRecurrenceRange aRepeatType )

                : iEditedCalEntry( aEntry ), iEntryUiInParams( aParams ), 

                iEntryUiCallback( aCallback ), iEntryUiOutParams( aOutParams ),

                iRepeatType( aRepeatType ), iEntryType( aEntry.EntryTypeL() ),

                iHasChosenRepeatType( ETrue ), iIgnoreFirstLocaleChange( ETrue ),

                iCurrentDurationDay( 0 ), iTwoSeconds( 2 )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditor::CCalenUnifiedEditor

// Default constructor

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

//

CCalenUnifiedEditor::CCalenUnifiedEditor( CCalEntry& aEntry,

                     const TAgnEntryUiInParams& aParams,

                     MAgnEntryUiCallback& aCallback,

                     TAgnEntryUiOutParams& aOutParams )

                : iEditedCalEntry( aEntry ), iEntryUiInParams( aParams ),

                iEntryUiCallback( aCallback ), iEntryUiOutParams( aOutParams ),

                iRepeatType( CalCommon::EThisAndAll ),

                iEntryType( aEntry.EntryTypeL() ),

                iHasChosenRepeatType( EFalse ),

                iIgnoreFirstLocaleChange( ETrue ),

                iCurrentDurationDay( 0 ), iTwoSeconds( 2 )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditor::ConstructL

// Second phase construction

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

//

void CCalenUnifiedEditor::ConstructL()

    {

    TRACE_ENTRY_POINT;

    // Construct dialog

    CAknDialog::ConstructL( R_CALEN_UNIFIED_EDITOR_MENUBAR );

    // Take a timestamp of the editors opening time - 2 seconds

    // We use this to compare against the last database change time

    // to determine if the current entry has been deleted through

    // another CCalSession

    iTimeStamp.UniversalTime();

    iGlobalData = CCalenGlobalData::InstanceL( iEntryUiInParams.iCalSession );

    iOriginalCalEntry = CCalenUnifiedEditor::CreateCopyL( iEditedCalEntry );

    // Setup title and status panes

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

    CAknTitlePane* tp = static_cast<CAknTitlePane*>( sp->ControlL( TUid::Uid(EEikStatusPaneUidTitle) ) );

    HBufC* titleText = StringLoader::LoadLC( R_QTN_CALE_UNIFIED_EDITOR_TITLE, iCoeEnv );

    tp->SetTextL( *titleText );

    CleanupStack::PopAndDestroy( titleText );

    // Put default, empty Status Pane.

    iNaviContainer = static_cast<CAknNavigationControlContainer *>( sp->ControlL(TUid::Uid(EEikStatusPaneUidNavi) ) );

    iNaviContainer->PushDefaultL();

    // Connect to services, and register for notifications of

    // changes to the database.

    TInt services( iEntryUiInParams.iSpare );

    iServices = reinterpret_cast< MCalenServices* >( services );

    RArray<TCalenNotification> notificationArray;

    notificationArray.Append( ECalenNotifyEntryDeleted );

    notificationArray.Append( ECalenNotifyInstanceDeleted );

    notificationArray.Append( ECalenNotifyDeleteFailed );

    notificationArray.Append( ECalenNotifyEntryInstanceViewCreated );

    notificationArray.Append( ECalenNotifyExternalDatabaseChanged );

    notificationArray.Append( ECalenNotifyMapClosed );

    notificationArray.Append( ECalenNotifyAttachmentAdded );

    notificationArray.Append( ECalenNotifyAttachmentRemoved );

    notificationArray.Append( ECalenNotifyCalendarFileDeleted );

    iServices->RegisterForNotificationsL( this, notificationArray );

    notificationArray.Reset();

    GetAllCollectionidsL(iCollectionIds);

    iEditorDataHandler = CCalenEditorDataHandler::NewL( iEditedCalEntry,

                                               iEntryUiInParams.iInstanceDate,

                                               IsCreatingNewEntry(),

                                               MaxTextEditorLength(),

                                               *iServices , iCollectionIds);

    iEntryUpdater = CCalenEntryUpdater::NewL( *iServices , iCollectionIds);

    //iServices->EntryViewL(iServices->Context().InstanceId().iColId);

    iUnifiedEditorControl = CCalenUnifiedEditorControl::NewL( *this,*iServices );

    isReplaceLocation = EFalse;

    iCheck = EFalse;

    TCallBack callback(CCalenUnifiedEditor::AsyncProcessCommandL,this);

    iAsyncCallback = new(ELeave) CAsyncCallBack(callback,CActive::EPriorityStandard);

    iIdle = CIdle::NewL( CActive::EPriorityUserInput );

    iIdle->Start( TCallBack( KeyCallBack, this) );

    iCoeEnv->AddFepObserverL( *this );

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditor::ExecuteViewL

// Dummy implementation. Use ExecuteLD() instead.

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

//

TInt CCalenUnifiedEditor::ExecuteViewL( RPointerArray<CCalEntry>& /*aEntries*/,

                                        const TAgnEntryUiInParams& /*aInParams*/,

                                        TAgnEntryUiOutParams& /*aOutParams*/,

                                        MAgnEntryUiCallback& /*aCallback*/ )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return KErrNone;

    }

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

// CCalenUnifiedEditor::SetHelpContext

// Sets the help context.

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

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

//

void CCalenUnifiedEditor::SetHelpContext( const TCoeHelpContext& /*aContext*/ )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditor::HandleNotification

// Handles calendar notifications

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

//

void CCalenUnifiedEditor::HandleNotification( TCalenNotification aNotification )

    {

    TRACE_ENTRY_POINT;

    switch( aNotification )

        {

        case ECalenNotifyExternalDatabaseChanged:

            {

            iLastDbChangeNotification.UniversalTime();

            }

            break;

        case ECalenNotifyEntryDeleted:

            {

            iEntryUiOutParams.iAction = MAgnEntryUi::EMeetingDeleted;

            PIM_TRAPD_HANDLE( CloseFormWithoutActionsL() );

            }

            break;

        case ECalenNotifyInstanceDeleted:

            {

            iEntryUiOutParams.iAction = MAgnEntryUi::EInstanceDeleted;

            PIM_TRAPD_HANDLE( CloseFormWithoutActionsL() );

            }

            break;

        case ECalenNotifyMapClosed:

            {

            // User has closed the map, store/update necessary details

            PIM_TRAPD_HANDLE( UpdateLocationInfoToFormL() );

            }

            break;

        case ECalenNotifyDeleteFailed:

            {

            iEntryUiOutParams.iAction = MAgnEntryUi::ENoAction;

            }

            break;

        case ECalenNotifyAttachmentAdded:

        case ECalenNotifyAttachmentRemoved:    

            {

            // TODO: Uncomment this when enabling attachment support

            PIM_TRAPD_HANDLE( UpdateAttachmentInfoToEditorL() );

            }

            break;

        case ECalenNotifyEntryInstanceViewCreated:

            break;

        case ECalenNotifyCalendarFileDeleted:

            {

            TPtrC fileNamePtr = iServices->Context().GetCalendarFileNameL();

            if(!fileNamePtr.CompareF(iUnifiedEditorControl->GetCalendarNameForEntryL()))

                {

                DisplayErrorMsgL( CCalenEditorDataHandler::EFormErrDbConflictEntryDeleted );

                iEntryUiOutParams.iAction = EMeetingDeleted;

                TryExitL( KCalenButtonIdCloseForm );

                }

            }

            break;

        default:

            break;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditor::InsertFieldL

// Inserts dialog line (form field) defined by aResourceI

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

//

void CCalenUnifiedEditor::InsertFieldL( TInt aResourceId, TInt aControlId,

                                        TInt aPrevControlId )

    {

    TRACE_ENTRY_POINT;

    CCoeControl* prevControl = Control( aPrevControlId );

    __ASSERT_DEBUG( prevControl, User::Invariant() );

    TInt pos = FindLineIndex( *prevControl );

    pos = pos + 1;

    InsertLineL( pos, aResourceId );

    // We need to activate line, otherwise drawing doesn't work correctly

    Line( aControlId )->ActivateL();

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditor::HasField

// Check for field exists in unified editor

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

//

TBool CCalenUnifiedEditor::HasField( TInt aField )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return ControlOrNull( aField ) != NULL;

    }

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

// CCalenUnifiedEditor::UpdateFormL

// Update form. You can force update of form with this,

// if you modify some of the field values dynamically. 

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

//

void CCalenUnifiedEditor::UpdateFormL()

    {

    TRACE_ENTRY_POINT;

    UpdatePageL(ETrue);

    TRACE_EXIT_POINT;

    }

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

// CreateCopyL

// Create a copy of the given entry.

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

//

CCalEntry* CCalenUnifiedEditor::CreateCopyL( CCalEntry& aOther )

    {

    TRACE_ENTRY_POINT;

    HBufC8* guid = aOther.UidL().AllocLC();

    CCalEntry* entry;

    if( aOther.RecurrenceIdL().TimeUtcL() != Time::NullTTime() )

        {

        entry = CCalEntry::NewL( aOther.EntryTypeL(), guid,

                                 aOther.MethodL(),

                                 aOther.SequenceNumberL(),

                                 aOther.RecurrenceIdL(),

                                 aOther.RecurrenceRangeL() );

        }

    else

        {

        entry = CCalEntry::NewL( aOther.EntryTypeL(), guid,

                                 aOther.MethodL(),

                                 aOther.SequenceNumberL() );

        }

    CleanupStack::Pop( guid ); // ownership was passed

    CleanupStack::PushL( entry );

    aOther.DescriptionL();  // make sure entry is fully loaded

    entry->CopyFromL( aOther );

    entry->DescriptionL();  // make sure entry is fully copied

    CleanupStack::Pop( entry );

    TRACE_EXIT_POINT;

    return entry;

    }

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

// CCalenUnifiedEditor::OkToExitL

// Handles exiting of the unified editor

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

//

TBool CCalenUnifiedEditor::OkToExitL( TInt aButtonId )

    {

    TRACE_ENTRY_POINT;

    TBool isExitForm( ETrue );

    TBool active = EFalse;

    TCalCollectionId colId = iEditorDataHandler->CurrentDbCollectionId(); 

    VerifyCollectionIdL(colId);

	TInt newCtrlId=IdOfFocusControl();

    switch ( aButtonId )

        {

        case EAknSoftkeyChange:

            {

            isExitForm=EFalse;

            // to Handle MSK key 'Change'

			if(newCtrlId == ECalenEditorEventType || newCtrlId == ECalenEditorRepeat

			                                      || newCtrlId == ECalenEditorDBName

			                                      || newCtrlId == ECalenEditorPriority)

				{

	            CEikCaptionedControl* line=CurrentLine();

	            TInt type=line->iControlType;

	            TBool isPopUp=( type && EAknCtPopupField ) || ( type == EAknCtPopupFieldText );

	            if (isPopUp)

	                {

	                CAknPopupField* ctrl = static_cast<CAknPopupField*>( line->iControl );

	                ctrl->ActivateSelectionListL();

	                }

				}

			else if( newCtrlId == ECalenEditorReminder ) 

                {

                if( iUnifiedEditorControl->IsAlarmActiveInForm() )

                    { 

                    SetAlarmFieldOnOffL( EFalse );           

                    active = EFalse;

                    } 

                else

                    {

                    SetAlarmFieldOnOffL( ETrue );