/*

* 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 policy implementation

*

*/

#include "cesmrviewerdialog.h"

#include "cesmrpolicy.h"

#include "esmrdef.h"

#include "cesmrpolicymanager.h"

#include "cesmrurlparserplugin.h"

#include "esmricalvieweropcodes.hrh"

#include "tesmrinputparams.h"

#include "cesmrview.h"

#include "esmrgui.hrh"

#include "cesmrfield.h"

#include "cesmrviewerfieldstorage.h"

#include "esmrentryhelper.h"

#include "mesmrmeetingrequestentry.h"

#include "esmrinternaluid.h"

#include "cesmrlistquery.h"

#include "cesmrconfirmationquery.h"

#include "cesmrsendui.h"

#include "cesmrcontactmenuhandler.h"

#include "cesmrfieldbuilderinterface.h"

#include "cesmrtrackingviewdialog.h"

#include "mesmruibase.h"

#include "cesmruifactory.h"

#include "cesmrlocationpluginhandler.h"

#include "cesmrfeaturesettings.h"

#include "esmrconfig.hrh"

#include "mesmrfieldevent.h"

#include "cmrtoolbar.h"

#include "cesmrlistquery.h"

#include "mmrinfoprovider.h"

#include "cmrfocusstrategyviewer.h"

#include "cesmrtitlepanehandler.h"

#include <data_caging_path_literals.hrh>

#include <esmrgui.rsg>

#include <esmrpolicies.rsg>

#include <aknnotewrappers.h>

#include <eikenv.h>

#include <eikappui.h>

#include <avkon.hrh>

#include <MAgnEntryUi.h>

#include <eikmenup.h>

#include <calentry.h>

#include <apgtask.h>

#include <apmstd.h>

#include <apgcli.h>

#include <AknDef.h>

#include <AknUtils.h>

#include <StringLoader.h>

#include <eikspane.h>

#include <e32keys.h>

#include <CalenInterimUtils2.h>

#include <w32std.h>

// DEBUG

#include "emailtrace.h"

#include "cesmrcaldbmgr.h"

/// Unnamed namespace for local definitions

namespace  { // codescanner::namespace

#ifdef _DEBUG

enum TESMRViewerDlgPanic

    {

    EESMRViewerDlgInvalidCommand,

    EESMRViewerDlgnvalidSeriesResult,

    EESMRViewerDlgInvalidEntry

    };

void Panic( TESMRViewerDlgPanic aPanic )

    {

    // Literal for viewer dialog

    _LIT( KESMRViewerDlgPanicTxt, "ESMRViewerDlg" );

    User::Panic( KESMRViewerDlgPanicTxt, aPanic );

    }

#endif

// Definition for default buffer length

const TInt KCalDefaultBufferLen = 40;

// VGA resolution screen size in pixels

const TInt KVGAOneSide( 640 );

const TInt KVGAOtherSide( 480 );

// Calendar command parameter

_LIT16( KCalCmdDATE, "GRAPHICDAY" );

// Definition for time format ("YYYY MM DD HH MM SS MMMMMM" - 26)

_LIT( KCalCmdTimeFormat, "%F %Y %M %D %H %T %S %C" );

// Definition for calendar application UID

const TUid KCalendarAppUID = { KUidCalendarApplication };

/**

 * 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 )

    {

    FUNC_LOG;

    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(EESMRViewerDlgnvalidSeriesResult) );

                break;

            	}

            }

        }

    else

        {

        aEntry.SetModifyingRuleL(

                MESMRMeetingRequestEntry::EESMRThisOnly );

        }

    }

}

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

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

// CESMRViewerDialog::CESMRViewerDialog

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

//

CESMRViewerDialog::CESMRViewerDialog(

        MMRInfoProvider& aInfoProvider,

        MAgnEntryUiCallback& aCallback  ) :

    iCallback( aCallback ),

    iInfoProvider( aInfoProvider )

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRViewerDialog::~CESMRViewerDialog

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

//

CESMRViewerDialog::~CESMRViewerDialog()

    {

    FUNC_LOG;

    iESMRStatic.Close();

    if ( iTitlePane )

        {

        // Returns the previous title back to titlepane

        iTitlePane->Rollback();

        delete iTitlePane;

        }

    delete iESMRSendUI;

    delete iLocationPluginHandler;

    delete iFeatures;

    // iView is deleted by framework because it uses the

    // custom control mechanism.

    delete iToolbar;

    delete iFocusStrategy;

    }

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

// CESMRViewerDialog::NewL

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

//

EXPORT_C CESMRViewerDialog* CESMRViewerDialog::NewL(

        MMRInfoProvider& aInfoProvider,

        MAgnEntryUiCallback& aCallback )

    {

    FUNC_LOG;

    CESMRViewerDialog* self =

        new (ELeave) CESMRViewerDialog( aInfoProvider, aCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRViewerDialog::ConstructL

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

//

void CESMRViewerDialog::ConstructL()

    {

    FUNC_LOG;

    iESMRStatic.ConnectL();

    CAknDialog::ConstructL( R_MRVIEWER_MENUBAR );

    // Class disables avkon toolbar by default, which

    // we want in case of non-MR

    iToolbar = CMRToolbar::NewL();

    TRect clientRect;

    AknLayoutUtils::LayoutMetricsRect(

            AknLayoutUtils::EMainPane,

            clientRect );

    TBool responseReady(EFalse);

    MESMRCalEntry* calEntry = iInfoProvider.EntryL();

    MESMRMeetingRequestEntry* mrEntry = NULL;

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

        {

        // This is meeting request

        mrEntry = static_cast<MESMRMeetingRequestEntry*>( calEntry );

        responseReady = mrEntry->IsSentL();

        // Change the status pane layout to remove navi pane

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

        sp->SwitchLayoutL(R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT);

        }

    iESMRSendUI = CESMRSendUI::NewL(EESMRCmdSendAs);

    CESMRViewerFieldStorage* storage =

            CESMRViewerFieldStorage::NewL(

                    iInfoProvider.PolicyProvider().CurrentPolicy(),

                    this,

                    responseReady,

                    *this );

    // Create focus strategy

    iFocusStrategy = CMRFocusStrategyViewer::NewL( *storage );

    // Give the strategy to the iView

    // storage ownership is transferred to CESMRView

    iView = CESMRView::NewL(

            storage,

            *calEntry,

            clientRect,

            *iFocusStrategy,

            *iToolbar,

            this );

    iView->SetViewMode( EESMRViewMR );

    if ( calEntry->Entry().SummaryL().Length() == 0 )

        {

        // if no title, set unnamed text:

        HBufC* title = StringLoader::LoadLC ( R_QTN_MEET_REQ_CONFLICT_UNNAMED,

                                              iCoeEnv );

        iView->SetTitleL( *title );

        CleanupStack::PopAndDestroy( title );

        }

    else

        {

        iView->SetTitleL( calEntry->Entry().SummaryL() );

        }

    TInt titleStringId = -1;

    switch ( calEntry->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::EESMRCalEntryAnniversary:

        	{

            titleStringId = R_QTN_CALENDAR_TITLE_ANNIVERSARY;

            break;

        	}

        case MESMRCalEntry::EESMRCalEntryReminder: // Fall through

        default:

        	{

            break;

        	}

        }

    if ( titleStringId != -1 )

        {

        if( !iTitlePane )

            {

            iTitlePane = CESMRTitlePaneHandler::NewL( *iEikonEnv );

            }

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

        iTitlePane->SetNewTitle( titleText );

        CleanupStack::PopAndDestroy( titleText );

        }

    iFeatures = CESMRFeatureSettings::NewL();

    }

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

// CESMRViewerDialog::ActivateL

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

//

void CESMRViewerDialog::ActivateL()

    {

    FUNC_LOG;

    iView->InternalizeL();

    CAknDialog::ActivateL();

    // Needs to be constructed here

    ConstructToolbarL();

    switch ( iInfoProvider.EntryL()->Type() )

    	{

    	case MESMRCalEntry::EESMRCalEntryMeetingRequest:

    		{

    		iView->InitialScrollL();

            MESMRMeetingRequestEntry* entry =

                static_cast<MESMRMeetingRequestEntry*>(

                        iInfoProvider.EntryL() );

    		if ( entry->IsOpenedFromMail() )

    		    {

                iView->SetNaviArrowStatus(

                                 iCallback.IsCommandAvailable(

                                        EESMRCmdMailPreviousMessage ),

                                 iCallback.IsCommandAvailable(

                                        EESMRCmdMailNextMessage ) );

    		    }

    		}

        case MESMRCalEntry::EESMRCalEntryMeeting:

        case MESMRCalEntry::EESMRCalEntryMemo:

        case MESMRCalEntry::EESMRCalEntryAnniversary:

        case MESMRCalEntry::EESMRCalEntryTodo:

    	case MESMRCalEntry::EESMRCalEntryReminder: // Fall through

    	default:

    		break;

    	}

    }

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

// CESMRViewerDialog::PreLayoutDynInitL

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

//

void CESMRViewerDialog::PreLayoutDynInitL()

    {

    FUNC_LOG;

    SetDefaultMiddleSoftKeyL();

    ButtonGroupContainer().MakeCommandVisibleByPosition(

            CEikButtonGroupContainer::EMiddleSoftkeyPosition,

            ETrue );

    }

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

// CESMRViewerDialog::OfferKeyEventL

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

//

TKeyResponse CESMRViewerDialog::OfferKeyEventL(

        const TKeyEvent& aEvent,

        TEventCode aType)

    {

    FUNC_LOG;

    TKeyResponse response( EKeyWasNotConsumed );

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

    	{

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

    	}

    if ( response == EKeyWasNotConsumed )

        {

        switch (aEvent.iScanCode)

            {

            case '4':

                {

                response = EKeyWasConsumed;

                ProcessCommandL(EESMRCmdMailPreviousMessage);

                break;

                }

            case '6':

                {

                response = EKeyWasConsumed;

                ProcessCommandL(EESMRCmdMailNextMessage);

                break;

                }

            default:

                {

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

                break;

                }

            }

        }

    return response;

    }

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

// CESMRViewerDialog::ProcessCommandL

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

//

void CESMRViewerDialog::ProcessCommandL( TInt aCommand )

    {

    FUNC_LOG;

    TRAPD( err, DoProcessCommandL( aCommand ) );

    if ( err != KErrNone &&

         err != KErrCancel &&

         err != KErrArgument )

        {

        User::Leave(err);

        }

    }

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

// CESMRViewerDialog::DoProcessCommandL

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

//

void CESMRViewerDialog::DoProcessCommandL( TInt aCommand )

    {

    FUNC_LOG;

    CAknDialog::ProcessCommandL( aCommand );

    switch ( aCommand )

        {

        case EESMRCmdSendAs:

            {

            SendCalendarEntryL(aCommand);

            break;

            }

        case EESMRCmdSendMR: //Fall through

        case EESMRCmdSendMRUpdate:

            {

            TInt ret( KErrGeneral );

            ret = iCallback.ProcessCommandWithResultL ( aCommand );

            if ( ret == KErrNone )

                {

                TryExitL ( EAknSoftkeyClose );

                }

            break;

            }

        // pass-through all calentryui related command to call back

        case EESMRCmdCalEntryUISend: // Fall through

        case EESMRCmdCalEntryUIAddParticipants: // Fall through

        case EESMRCmdCalEntryUISave: // Fall through

            {

            User::LeaveIfError(

            	iCallback.ProcessCommandWithResultL( aCommand ));

            break;

            }

        // EEikBidCancel is called when Red End key is pressed or

        // application is killed via Swap Window

        case EEikBidCancel: // Fall through

        case EAknSoftkeyClose: // Fall through

        case EAknCmdExit:

        	{

            TryExitL( aCommand );

            break;

        	}

        case EAknSoftkeySelect: // Fall through

            {

            iView->ProcessEditorCommandL( aCommand );

            break;

            }

        case EESMRCmdEdit:              // Fall through

        case EESMRCmdEditLocal:         // Fall through

        case EESMRCmdDeleteMR:          // Fall through

        case EESMRCmdCalEntryUIEdit:    // Fall through

        case EESMRCmdCalEntryUIDelete:

            {

            TBool closeDialog = HandleCommandForEventL( aCommand );

            if ( closeDialog )

                {

                TryExitL( EAknSoftkeyClose );

                }

            break;

            }