/*

* Copyright (c) 2007-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 "emailtrace.h"

#include "cesmreditordialog.h"

//<cmail>

#include "esmrdef.h"

#include <esmrgui.rsg>

#include "cesmrpolicy.h"

//</cmail>

#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 <calentry.h>

#include <CalenInterimUtils2.h>

#include <akntitle.h>

#include <StringLoader.h>

//<cmail>

#include <featmgr.h>

//</cmail>

#include "esmrcommands.h"

//</cmail>

#include <AiwServiceHandler.h>

#include <featmgr.h>

#include <bldvariant.hrh>

#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"

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

// Unnamed namespace for local definitions

namespace { // codescanner::namespace

#ifdef _DEBUG

    _LIT( KESMREditDlgPanicTxt, "ESMREDITORDIALOG" );

    /** Enumeration for panic codes */

    enum TESMREditDlgPanicCode

        {

        // Recurrence series query result error

        EESMREditDlgInvalidSeriesResult = 0,

        EESMREditDlgDialogLeave

        };

    void Panic( TESMREditDlgPanicCode aPanic )

        {

        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 aPolicy. Pointer to used policy.

 * @param aResponseObserver Pointer to response observer.

 */

CESMRFieldStorage* CreateCorrectStorageLC(

        MESMRFieldEventObserver& aEventObserver,

        MESMRCalEntry& aEntry,

        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(

        MESMRCalEntry& aEntry,

        MAgnEntryUiCallback& aCallback ) :

    iEntry( aEntry), iCallback( aCallback)

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMREditorDialog::~CESMREditorDialog

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

//

CESMREditorDialog::~CESMREditorDialog( )

    {

    FUNC_LOG;

    if ( iFeatureManagerInitialized )

        {

        FeatureManager::UnInitializeLib();

        }

    if ( iServiceHandler )

        {

        iServiceHandler->DetachMenu ( 

        		R_MR_EDITOR_ORGANIZER_MENU, 

        		R_PS_AIW_INTEREST );

        delete iServiceHandler;

        }

    delete iESMRSendUI;

    if ( iTitlePane )

        {

        // Returns the previous title back to titlepane

        iTitlePane->Rollback();

        delete iTitlePane;

        }

    delete iInterimUtils;

    delete iLocationPluginHandler;

    delete iAddressInfoHandler;

    delete iFeatures;

    // iView is deleted by framework because it uses the

    // custom control mechanism.

    }

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

// CESMREditorDialog::NewL

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

//

EXPORT_C CESMREditorDialog* CESMREditorDialog::NewL(

        CESMRPolicy* aPolicy,

        MESMRCalEntry& aEntry,

        MAgnEntryUiCallback& aCallback )

    {

    FUNC_LOG;

    CESMREditorDialog* self =

    new (ELeave) CESMREditorDialog( aEntry, aCallback );

    CleanupStack::PushL( self );

    self->ConstructL( aPolicy );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMREditorDialog::ConstructL

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

//

void CESMREditorDialog::ConstructL(

        CESMRPolicy* aPolicy )

    {

    FUNC_LOG;

    CAknDialog::ConstructL ( R_MREDITOR_MENUBAR );

    iPolicy = aPolicy;

    iESMRSendUI = CESMRSendUI::NewL (EESMRCmdSendAs );

    FeatureManager::InitializeLibL();

    iFeatureManagerInitialized = ETrue;

    // <cmail> remove custom feature KFeatureIdPrintingFrameworkCalendarPlugin 

    // </cmail>	

    CESMRFieldStorage* storage =

            CreateCorrectStorageLC( *this, iEntry, aPolicy, this );

    TRect clientRect;

    AknLayoutUtils::LayoutMetricsRect(

            AknLayoutUtils::EMainPane,

            clientRect );

    // storage ownership is transferred to CESMRView

    iView = CESMRView::NewL( storage, iEntry, clientRect );

    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;

            }

        }

    TInt titleStringId = -1;

    switch ( iEntry.Type() )

        {

        case MESMRCalEntry::EESMRCalEntryMeetingRequest:

            titleStringId = R_QTN_MEET_REQ_TITLE_MEETING;

            break;

        case MESMRCalEntry::EESMRCalEntryMeeting:

            titleStringId = R_QTN_CALENDAR_TITLE_MEETING;

            break;

        case MESMRCalEntry::EESMRCalEntryTodo:

            titleStringId = R_QTN_CALENDAR_TITLE_TODO;

            break;

        case MESMRCalEntry::EESMRCalEntryMemo:

            titleStringId = R_QTN_CALENDAR_TITLE_MEMO;

            break;

        case MESMRCalEntry::EESMRCalEntryReminder:

            break;

        case MESMRCalEntry::EESMRCalEntryAnniversary:

            titleStringId = R_QTN_CALENDAR_TITLE_ANNIVERSARY;

            break;

        default:

            break;

        }

    if ( titleStringId != -1 )

        {

        iTitlePane = CESMRTitlePaneHandler::NewL( *iEikonEnv );

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

        iTitlePane->SetNewTitle( titleText );

        CleanupStack::PopAndDestroy( titleText );

        }

    if(!iInterimUtils)

        {

        iInterimUtils = CCalenInterimUtils2::NewL();

        }

    iFeatures = CESMRFeatureSettings::NewL();

    if ( iFeatures->FeatureSupported(

            CESMRFeatureSettings::EESMRUILocationFeatures ) )

        {

        if ( iPolicy->FieldL( EESMRFieldLocation ).iFieldMode == EESMRFieldModeEdit )

            {

            iMenuBar->SetContextMenuTitleResourceId( R_MR_EDITOR_CONTEXT_MENU );

            }

        else

            {

            iMenuBar->SetContextMenuTitleResourceId( R_MR_VIEWER_CONTEXT_MENU );

            }        

        }

    }

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

// 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 );

    switch ( aButtonId )

        {

        case EAknSoftkeyOptions:

            {

            // Show options menu

            CAknDialog::DisplayMenuL();

            break;

            }

        case EESMRCmdSaveMR:

            {

            ProcessCommandL( EESMRCmdSaveMR );

            break;

            }

        case EAknSoftkeyContextOptions:

            {

            // Show context menu

            if ( iFeatures->FeatureSupported(

                    CESMRFeatureSettings::EESMRUILocationFeatures ) )

                {

                iMenuBar->TryDisplayContextMenuBarL();

                }

            break;            

            }

        case EESMRCmdAlarmOn:

        case EESMRCmdAlarmOff:

        case EESMRCmdOpenPriorityQuery:

        case EESMRCmdOpenSyncQuery:

        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;

            }