/*

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

*

*/

#include "emailtrace.h"

#include "cesmrviewerdialog.h"

#include <data_caging_path_literals.hrh>

#include <esmrgui.rsg>

#include <esmrpolicies.rsg>

#include <eikenv.h>

#include <eikappui.h>

#include <avkon.hrh>

#include <MAgnEntryUi.h>

#include <eikmenup.h>

#include <calentry.h>

#include <apgtask.h>

#include <apgcli.h>

#include <AknDef.h>

#include <AknUtils.h>

#include <StringLoader.h>

#include <akntitle.h>

#include <eikspane.h>

#include <e32keys.h>

#include <AiwServiceHandler.h>

#include <featmgr.h>

#include <bldvariant.hrh>

#include <akntoolbar.h>

#include <aknappui.h>

#include <aknViewAppUi.h>

#include <aknview.h>

#include <eikcolib.h>

#include <aknbutton.h>

#include <aknnavi.h>

#include <aknnavide.h>

#include <msvuids.h>

//</cmail>

#include <featmgr.h>

//</cmail>

#include <cmrmailboxutils.h>

#include "cesmrpolicy.h"

#include "esmrdef.h"

#include "cesmrpolicymanager.h"

#include "cesmrurlparserplugin.h"

#include "esmricalvieweropcodes.hrh"

#include "tesmrinputparams.h"

#include "cesmrattachmentinfo.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 "CFSMailBox.h"

/// Unnamed namespace for local definitions

namespace  { // codescanner::namespace

#ifdef _DEBUG

// Literal for viewer dialog

_LIT( KESMRViewerDlgPanicTxt, "ESMRViewerDlg" );

enum TESMRViewerDlgPanic

    {

    EESMRViewerDlgInvalidCommand,

    EESMRViewerDlgnvalidSeriesResult,

    EESMRViewerDlgInvalidEntry

    };

void Panic( TESMRViewerDlgPanic aPanic )

    {

    User::Panic( KESMRViewerDlgPanicTxt, aPanic );

    }

#endif

// Definition for default buffer length

const TInt KCalDefaultBufferLen = 40;

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

// Defs for prefix

_LIT( KMailtoMatchPattern, "mailto:*" ); // these are never localized

const TInt KMailtoLength = 7; // "mailto:" length

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

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

// Set empty buttons to toolbar.

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

//

void SetEmptyButtonsL( CAknToolbar* aToolbar )

    {

    aToolbar->AddItemL( CAknButton::NewL(), EAknCtButton, EESMRCmdUndefined, 0, 0 );

    aToolbar->AddItemL( CAknButton::NewL(), EAknCtButton, EESMRCmdUndefined, 0, 1 );

    aToolbar->AddItemL( CAknButton::NewL(), EAknCtButton, EESMRCmdUndefined, 0, 2 );

    }

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

// Set buttons for responding to meeting request to toolbar.

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

//

void SetResponseButtonsL( CAknToolbar* aToolbar )

    {

    CAknButton* buttonAccept = CAknButton::NewLC();

    buttonAccept->ConstructFromResourceL( R_ACCEPT_BUTTON );

    aToolbar->AddItemL( buttonAccept, EAknCtButton, EESMRCmdAcceptMR, 0, 0 );

    CleanupStack::Pop( buttonAccept );

    CAknButton* buttonTentative = CAknButton::NewLC();

    buttonTentative->ConstructFromResourceL( R_TENTATIVE_BUTTON );

    aToolbar->AddItemL( buttonTentative, EAknCtButton, EESMRCmdTentativeMR, 0, 1 );

    CleanupStack::Pop( buttonTentative );

    CAknButton* buttonDecline = CAknButton::NewLC();

    buttonDecline->ConstructFromResourceL( R_DECLINE_BUTTON );

    aToolbar->AddItemL( buttonDecline, EAknCtButton, EESMRCmdDeclineMR, 0, 2 );

    CleanupStack::Pop( buttonDecline );

    }

/**

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

        MESMRCalEntry& aEntry,

        MAgnEntryUiCallback& aCallback  ) :

    iEntry( aEntry ),

    iCallback( aCallback ),

    iClearToolbar( EFalse )

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRViewerDialog::~CESMRViewerDialog

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

//

CESMRViewerDialog::~CESMRViewerDialog()

    {

    FUNC_LOG;

    if ( iIdleNaviEventRunner )

        {

        iIdleNaviEventRunner->Cancel();

        delete iIdleNaviEventRunner;

        }

    iESMRStatic.Close();

    if ( iFeatureManagerInitialized )

        {

        FeatureManager::UnInitializeLib();

        }

    if ( iServiceHandler )

        {

        iServiceHandler->DetachMenu( R_MRVIEWER_MENUBAR, R_PS_AIW_INTEREST );

        delete iServiceHandler;

        }

    delete iESMRSendUI;

    delete iLocationPluginHandler;

    delete iFeatures;

    TRAP_IGNORE( ClearToolbarL() );

    // iView is deleted by framework because it uses the

    // custom control mechanism.

    }

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

// CESMRViewerDialog::NewL

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

//

EXPORT_C CESMRViewerDialog* CESMRViewerDialog::NewL(

        CESMRPolicy* aPolicy,

        MESMRCalEntry& aEntry,

        MAgnEntryUiCallback& aCallback )

    {

    FUNC_LOG;

    CESMRViewerDialog* self =

        new (ELeave) CESMRViewerDialog( aEntry, aCallback );

    CleanupStack::PushL( self );

    self->ConstructL( aPolicy );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRViewerDialog::ConstructL

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

//

void CESMRViewerDialog::ConstructL(

        CESMRPolicy* aPolicy )

    {

    FUNC_LOG;

    iIdleNaviEventRunner = CIdle::NewL( CActive::EPriorityStandard );

    iPolicy = aPolicy;

    iESMRStatic.ConnectL();

    CAknDialog::ConstructL( R_MRVIEWER_MENUBAR );

    TRect clientRect;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, clientRect );

    TBool responseReady(EFalse);

    MESMRMeetingRequestEntry* mrEntry = NULL;

    if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry.Type() )

        {

        // This is meeting request

        mrEntry = static_cast<MESMRMeetingRequestEntry*>( &iEntry );

        responseReady = mrEntry->IsSentL();

        }

    iESMRSendUI = CESMRSendUI::NewL(EESMRCmdSendAs);

    FeatureManager::InitializeLibL();

    iFeatureManagerInitialized = ETrue;

    CESMRViewerFieldStorage* storage =

            CESMRViewerFieldStorage::NewL(

                    aPolicy,

                    this,

                    responseReady,

                    *this );

    // storage ownership is transferred to CESMRView

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

    if ( iEntry.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( iEntry.Entry().SummaryL() );

        }

    TInt titleStringId = -1;

    switch ( iEntry.Type() )

        {

        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        	

        case MESMRCalEntry::EESMRCalEntryMeetingRequest: // Fall through

        default:

        	{

            break;

        	}

        }

    if ( titleStringId != -1 )

        {

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

        CAknTitlePane* tp = 

			static_cast<CAknTitlePane*>( 

					sp->ControlL(TUid::Uid(EEikStatusPaneUidTitle)) );

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

        tp->SetTextL( *titleText );

        CleanupStack::PopAndDestroy( titleText );

        }

    iFeatures = CESMRFeatureSettings::NewL();

    if ( iFeatures->FeatureSupported(

            CESMRFeatureSettings::EESMRUIMnFwIntegration ) )

        {

        iMenuBar->SetContextMenuTitleResourceId( R_MR_VIEWER_CONTEXT_MENU );

        }

    // start to observe navigation decorator

    CEikStatusPane* sp =

        static_cast<CEikAppUiFactory*>( 

                iEikonEnv->AppUiFactory() )->StatusPane();

    CAknNavigationControlContainer* naviPane =

        static_cast<CAknNavigationControlContainer*>( 

                sp->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );

    if ( naviPane )

        {

        iESMRNaviDecorator = naviPane->Top();

        if ( iESMRNaviDecorator )

            {

            iESMRNaviDecorator->SetNaviDecoratorObserver( this );

            }

        }

    //start service handler and add the interests of this class

    iServiceHandler = CAiwServiceHandler::NewL();

    iServiceHandler->AttachL( R_PS_AIW_INTEREST );

    }

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

// CESMRViewerDialog::ActivateL

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

//

void CESMRViewerDialog::ActivateL()

    {

    FUNC_LOG;

    iView->InternalizeL();

    CAknDialog::ActivateL();

    }

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

// 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 EStdKeyLeftArrow:

                if ( aType == EEventKey )

                    {

                    response = EKeyWasConsumed;

                    if ( iCallback.IsCommandAvailable(

                            EESMRCmdMailPreviousMessage ) )

                        {

                        ProcessCommandL( EESMRCmdMailPreviousMessage );

                        }

                    }

                break;

            case EStdKeyRightArrow:

                if ( aType == EEventKey )

                    {

                    response = EKeyWasConsumed;

                    if ( iCallback.IsCommandAvailable(

                            EESMRCmdMailNextMessage ) )

                        {

                        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 EESMRCmdPrint: // Fall through

        case EESMRCmdPrint_Reserved1: // Fall through

        case EESMRCmdPrint_Reserved2: // Fall through

        case EESMRCmdPrint_Reserved3: // Fall through

        case EESMRCmdPrint_Reserved4:

            {

            this->MakeVisible(EFalse); 

            HandlePrintCommandL(aCommand);

            this->MakeVisible(ETrue);