/*

* 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:  ESMR editor dialog

*

*/

#include "cesmreditordialog.h"

#include "esmrgui.hrh"

#include "cesmrview.h"

#include "mesmrmeetingrequestentry.h"

#include "cesmrconfirmationquery.h"

#include "cesmrlistquery.h"

#include "cesmreditorfieldstorage.h"

#include "cesmrmixedfieldstorage.h"

#include "cesmrsendui.h"

#include "cesmrfield.h"

#include "cesmrfieldbuilderinterface.h"

#include "mesmrresponseobserver.h"

#include "cesmrglobalnote.h"

#include "cesmrtitlepanehandler.h"

#include "esmrinternaluid.h"

#include "cesmrlocationpluginhandler.h"

#include "cesmraddressinfohandler.h"

#include "cesmrfeaturesettings.h"

#include "mesmrfieldevent.h"

#include "esmrconfig.hrh"

#include "esmrdef.h"

#include "esmrcommands.h"

#include "cesmrpolicy.h"

#include "cmrtoolbar.h"

#include "mmrpolicyprovider.h"

#include "mmrinfoprovider.h"

#include "cesmrcaldbmgr.h"

#include "cmrfocusstrategyeditor.h"

#include "cesmrfieldbuilderinterface.h"

#include <esmrgui.rsg>

#include <apgcli.h>

#include <eikenv.h>

#include <eikappui.h>

#include <avkon.hrh>

#include <eikmenup.h>

#include <MAgnEntryUi.h>

#include <layoutmetadata.cdl.h>

#include <AknDef.h>

#include <AknUtils.h>

#include <AknIndicatorContainer.h>

#include <aknenv.h>

#include <aknEditStateIndicator.h>

#include <aknnotewrappers.h>

#include <DocumentHandler.h>

#include <NpdApi.h>

#include <calentry.h>

#include <calattachment.h>

#include <CalenInterimUtils2.h>

#include <akntitle.h>

#include <StringLoader.h>

// DEBUG

#include "emailtrace.h"

// <cmail> Removed profiling. </cmail>

// Unnamed namespace for local definitions

namespace { // codescanner::namespace

#ifdef _DEBUG

    /** Enumeration for panic codes */

    enum TESMREditDlgPanicCode

        {

        // Recurrence series query result error

        EESMREditDlgInvalidSeriesResult = 0,

        EESMREditDlgDialogLeave

        };

    void Panic( TESMREditDlgPanicCode aPanic )

        {

        _LIT( KESMREditDlgPanicTxt, "ESMREDITORDIALOG" );

        User::Panic ( KESMREditDlgPanicTxt, aPanic );

        }

#endif

/**

 * Sets recurrence modification rule to entry. Rule is queried

 * from the user. Invalid result will cause panic.

 * @param aEntry Reference to meeting request.

 */

void SetRecurrenceModRuleL(

        MESMRCalEntry& aEntry,

        CESMRListQuery::TESMRListQueryType aQueryType )

    {

    if ( aEntry.IsRecurrentEventL() &&

         aEntry.IsStoredL() )

        {

        TInt result =

            CESMRListQuery::ExecuteL( aQueryType );

        if( KErrCancel == result )

            {

            // User has cancelled selecting opening the instance

            User::Leave( KErrCancel );

            }

        TESMRThisOccurenceOrSeriesQuery recurrenceModRule =

            static_cast<TESMRThisOccurenceOrSeriesQuery>( result );

        switch( recurrenceModRule )

            {

            case EESMRThisOccurence:

                {

                aEntry.SetModifyingRuleL(

                        MESMRMeetingRequestEntry::EESMRThisOnly );

                }

                break;

            case EESMRSeries:

                {

                aEntry.SetModifyingRuleL(

                        MESMRMeetingRequestEntry::EESMRAllInSeries );

                }

                break;

            default:

                __ASSERT_DEBUG( EFalse, Panic(EESMREditDlgInvalidSeriesResult));

                break;

            }

        }

    else

        {

        aEntry.SetModifyingRuleL(

                MESMRMeetingRequestEntry::EESMRThisOnly );

        }

    }

/**

 * Creates correct type of storage for editing calendar entry.

 * @param aCommandObserver Reference to command observer

 * @param aEntry Reference to ES calendar entry

 * @param aPolicyProvider. Pointer to used policy.

 * @param aResponseObserver Pointer to response observer.

 */

CESMRFieldStorage* CreateCorrectStorageLC(

        MESMRFieldEventObserver& aEventObserver,

        MESMRCalEntry& aEntry,

        const CESMRPolicy& aPolicy,

        MESMRResponseObserver* aResponseObserver )

    {

    CESMRFieldStorage* storage = NULL;

    MESMRCalEntry::TESMRRecurrenceModifyingRule rule(

            aEntry.RecurrenceModRule() );

    TESMRViewMode mode( aPolicy.ViewMode() );

    if ( ( aEntry.IsRecurrentEventL() &&

           rule == MESMRCalEntry::EESMRThisOnly ) ||

           mode == EESMRForwardMR )

        {

        // instance editing or forwarding entry

        storage = CESMRMixedFieldStorage::NewL(

                aEventObserver,

                aPolicy,

                aResponseObserver,

                aEntry );

        CleanupStack::PushL ( storage );

        }

    else if ( aEntry.IsRecurrentEventL() &&

              rule == MESMRCalEntry::EESMRAllInSeries  )

        {

        // Editing all in series

        storage = CESMRMixedFieldStorage::NewL(

                aEventObserver,

                aPolicy,

                aResponseObserver,

                aEntry );

        CleanupStack::PushL ( storage );

        }

    else

        {

        storage = CESMREditorFieldStorage::NewL ( aPolicy, aEventObserver );

        CleanupStack::PushL ( storage );

        }

    return storage;

    }

/**

 * Tests if two datetime objects has same day or not.

 * @param aLhs Reference to left hand side datetime object.

 * @param aRhs Reference to right hand side datetime object.

 */

TBool IsSameDay(

        TDateTime& aLhs,

        TDateTime& aRhs )

    {

    TBool retValue( ETrue );

    if ( aLhs.Day()     != aRhs.Day() ||

         aLhs.Month() != aRhs.Month() ||

         aLhs.Year()  != aRhs.Year() )

        {

        retValue = EFalse;

        }

    return retValue;

    }

} // namespace

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

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

// CESMREditorDialog::CESMREditorDialog

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

//

CESMREditorDialog::CESMREditorDialog(

        MMRInfoProvider& aInfoProvider,

        MAgnEntryUiCallback& aCallback ) :

    iInfoProvider( aInfoProvider ),

    iCallback( aCallback)

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMREditorDialog::~CESMREditorDialog

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

//

CESMREditorDialog::~CESMREditorDialog( )

    {

    FUNC_LOG;

    delete iESMRSendUI;

    if ( iTitlePane )

        {

        // Returns the previous title back to titlepane

        iTitlePane->Rollback();

        delete iTitlePane;

        }

    delete iInterimUtils;

    delete iLocationPluginHandler;

    delete iAddressInfoHandler;

    delete iFeatures;

    delete iToolbar;

    delete iFocusStrategy;

    // iView is deleted by framework because it uses the

    // custom control mechanism.

    }

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

// CESMREditorDialog::NewL

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

//

EXPORT_C CESMREditorDialog* CESMREditorDialog::NewL(

        MMRInfoProvider& aInfoProvider,

        MAgnEntryUiCallback& aCallback )

    {

    FUNC_LOG;

    CESMREditorDialog* self =

    new (ELeave) CESMREditorDialog( aInfoProvider, aCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMREditorDialog::ConstructL

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

//

void CESMREditorDialog::ConstructL()

    {

    FUNC_LOG;

    CAknDialog::ConstructL ( R_MREDITOR_MENUBAR );

    iESMRSendUI = CESMRSendUI::NewL (EESMRCmdSendAs );

    MESMRCalEntry* entry = iInfoProvider.EntryL();

    CESMRFieldStorage* storage = CreateCorrectStorageLC(

            *this,

            *entry,

            iInfoProvider.PolicyProvider().CurrentPolicy(),

            this );

    iStartTimeUtc = entry->Entry().StartTimeL().TimeUtcL();

    //clean previous toolbar if there is, and be sure restore toolbar area to EMainPane

    iToolbar = CMRToolbar::NewL();

    TRect clientRect;

    AknLayoutUtils::LayoutMetricsRect(

            AknLayoutUtils::EMainPane,

            clientRect );

    // Create focus strategy

    iFocusStrategy = CMRFocusStrategyEditor::NewL( *storage );

    // storage ownership is transferred to CESMRView

    iView = CESMRView::NewL( 

            storage, 

            *entry, 

            clientRect, 

            *iFocusStrategy,

            *iToolbar );

    iView->SetViewMode( EESMREditMR );

    CleanupStack::Pop( storage );

    // try to find subject field and set title pane observer

    CESMRField* field = NULL;

    TInt fieldCount( storage->Count() );

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

        {

        field = storage->Field( i );

        TESMREntryFieldId fieldId( field->FieldId() );

        switch (fieldId)

            {

            case EESMRFieldSubject: //Fall through

            case EESMRFieldOccasion://Fall through

            case EESMRFieldPriority://Fall through

            case EESMRFieldDetailedSubject:

                {

                field->SetTitlePaneObserver( iView );

                break;

                }

            default:

                break;

            }

        }

    SetTitleL();

    if(!iInterimUtils)

        {

        iInterimUtils = CCalenInterimUtils2::NewL();

        }

    iFeatures = CESMRFeatureSettings::NewL();

    }

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

// CESMREditorDialog::CreateCustomControlL

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

//

SEikControlInfo CESMREditorDialog::CreateCustomControlL(

        TInt aType )

    {

    FUNC_LOG;

    SEikControlInfo controlInfo;

    controlInfo.iControl = NULL;

    controlInfo.iFlags = 0;

    controlInfo.iTrailerTextId = 0;

    if ( aType == EEsMrEditorType )

        {

        controlInfo.iControl = iView;

        }

    return controlInfo;

    }

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

// CESMREditorDialog::OfferKeyEventL

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

//

TKeyResponse CESMREditorDialog::OfferKeyEventL(

        const TKeyEvent& aEvent,

        TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response( EKeyWasNotConsumed);

    if ( aEvent.iCode != EKeyEscape && !MenuShowing() && aType == EEventKey)

        {

        response = iView->OfferKeyEventL ( aEvent, aType );

        }

    if ( response == EKeyWasNotConsumed  )

        {

        response = CAknDialog::OfferKeyEventL ( aEvent, aType );

        }

    return response;

    }

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

// CESMREditorDialog::OkToExitL

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

//

TBool CESMREditorDialog::OkToExitL( TInt aButtonId )

    {

    FUNC_LOG;

    TBool res( EFalse );

    MESMRCalEntry* entry = iInfoProvider.EntryL();

    switch ( aButtonId )

        {

        case EAknSoftkeyOptions:

            {

            // Show options menu

            CAknDialog::DisplayMenuL();

            break;

            }

        case EAknSoftkeySend:

        	{

            if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == entry->Type() )

                {

                MESMRMeetingRequestEntry* mrEntry =

                        static_cast<MESMRMeetingRequestEntry*>( 

                                iInfoProvider.EntryL() );

                const CESMRPolicy& policy = Policy();

                if ( policy.IsDefaultCommand(EESMRCmdSendMRUpdate ) &&

                        ( mrEntry->IsSentL() && mrEntry->IsStoredL() ) )

                    {

                    ProcessCommandL( EESMRCmdSendMRUpdate );

                    }

                else

                    {

                    ProcessCommandL( EESMRCmdSendMR );

                    }

                }

        	break;

            }

        case EESMRCmdSaveMR:

            {

            ProcessCommandL( EESMRCmdSaveMR );

            break;

            }

        case EESMREditorAddAttachment:

            {

            ProcessCommandL( EESMREditorAddAttachment );

            break;

            }

        case EESMRCmdLongtapDetected:

        case EAknSoftkeyContextOptions:

            {

            if( SetContextMenuL() )

                {

                ShowContextMenuL();;

                }

            break;

            }

        case EESMRCmdAlarmOn:

        case EESMRCmdAlarmOff:

        case EESMRCmdOpenPriorityQuery:

        case EESMRCmdOpenSyncQuery:

        case EESMRCmdOpenUnifiedEditorQuery:

        case EESMRCmdOpenMultiCalenSelectQuery:

        case EESMRCmdOpenRecurrenceQuery:

        case EESMRCmdOpenAlarmQuery:

        case EESMRCmdCheckEvent:

        case EESMRCmdAttendeeSoftkeySelect:

        case EESMRCmdAttendeeSoftkeyCancel:

        case EESMRCmdAttendeeInsertContact:

            {

            // Forward to editor

            TRAPD( err, iView->ProcessEditorCommandL( aButtonId ) )

            if ( err != KErrNone &&

                 err != KErrCancel &&

                 err != KErrArgument )

                {

                User::Leave(err);

                }

            break;

            }

        case EESMRCmdForceExit:

        case EESMRCmdCalEntryUIDelete:

        case EESMRCmdDeleteMR:

            {

            res = ETrue;

            break;

            }

        case EAknSoftkeyDone:

            {

            // Exit dialog

            TRAPD( err, HandleExitL() )

            switch ( err )

                {

                case KErrNone:

                    {

                    res = ETrue;

                    break;

                    }

                case KErrArgument:

                    {

                    res = EFalse;

                    break;

                    }

                default:

                    {

                    User::Leave( err );

                    break;

                    }

                }

            break;

            }

        case EAknCmdExit:

        case EEikBidCancel:

            {

            // Force exit. Don't care about exceptions

            // just close the dialog