/*

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

/// Unnamed namespace for local definitions

namespace  { // codescanner::namespace

#ifdef _DEBUG

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

/**

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

            	{

                		Panic(EESMRViewerDlgnvalidSeriesResult) );

                break;

            	}

            }

        }

    else

        {

        aEntry.SetModifyingRuleL(

                MESMRMeetingRequestEntry::EESMRThisOnly );

        }

    }

}

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

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

// CESMRViewerDialog::CESMRViewerDialog

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

//

CESMRViewerDialog::CESMRViewerDialog(

        MAgnEntryUiCallback& aCallback  ) :

    iCallback( aCallback ),

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRViewerDialog::~CESMRViewerDialog

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

//

CESMRViewerDialog::~CESMRViewerDialog()

    {

    FUNC_LOG;

    iESMRStatic.Close();

        {

        }

    delete iESMRSendUI;

    delete iLocationPluginHandler;

    delete iFeatures;

    // iView is deleted by framework because it uses the

    // custom control mechanism.

    }

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

// CESMRViewerDialog::NewL

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

//

EXPORT_C CESMRViewerDialog* CESMRViewerDialog::NewL(

        MAgnEntryUiCallback& aCallback )

    {

    FUNC_LOG;

    CESMRViewerDialog* self =

    CleanupStack::PushL( self );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRViewerDialog::ConstructL

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

//

    {

    FUNC_LOG;

    iESMRStatic.ConnectL();

    CAknDialog::ConstructL( R_MRVIEWER_MENUBAR );

    TRect clientRect;

    TBool responseReady(EFalse);

    MESMRMeetingRequestEntry* mrEntry = NULL;

        {

        // This is meeting request

        responseReady = mrEntry->IsSentL();

        }

    iESMRSendUI = CESMRSendUI::NewL(EESMRCmdSendAs);

    CESMRViewerFieldStorage* storage =

            CESMRViewerFieldStorage::NewL(

                    this,

                    responseReady,

                    *this );

    // storage ownership is transferred to CESMRView

        {

        // if no title, set unnamed text:

        HBufC* title = StringLoader::LoadLC ( R_QTN_MEET_REQ_CONFLICT_UNNAMED,

                                              iCoeEnv );

        iView->SetTitleL( *title );

        CleanupStack::PopAndDestroy( title );

        }

    else

        {

        }

    TInt titleStringId = -1;

        {

        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;

        	}

        default:

        	{

            break;

        	}

        }

    if ( titleStringId != -1 )

        {

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

        CleanupStack::PopAndDestroy( titleText );

        }

    iFeatures = CESMRFeatureSettings::NewL();

    }

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

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

    if ( response == EKeyWasNotConsumed )

        {

        switch (aEvent.iScanCode)

            {

                break;

                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;

            }

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

        case EESMRCmdCalEntryUISend: // Fall through

        case EESMRCmdCalEntryUIAddParticipants: // Fall through

        case EESMRCmdCalEntryUISave: // Fall through

            {

            	iCallback.ProcessCommandWithResultL( aCommand ));

            break;

        // application is killed via Swap Window

        case EEikBidCancel: // Fall through

        case EAknSoftkeyClose: // Fall through

        case EAknCmdExit:

        	{

            TryExitL( aCommand );

            break;

        	}

        case EAknSoftkeySelect: // Fall through

            {