/*

* Copyright (c) 2008 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:   Form class for creating events.

*

*/

#include <evtmgmteditorui.rsg>

#include <avkon.rsg>

#include <avkon.hrh>

#include <eikedwin.h>

#include <eikmenup.h>

#include <eikenv.h>

#include <aknlistquerydialog.h>

#include <StringLoader.h>

#include <eikaufty.h>

#include <AknPopupFieldText.h> 

#include <eikenv.h>

#include <eikspane.h>       // Status pane

#include <akntitle.h>       // CAknTitlePane

#include <aknuniteditor.h> 

#include <e32math.h>

#include <AknIconArray.h>       // Icon Array

#include <evteditor.mbg>

#include <AknsUtils.h>

#include <AknsSkinInstance.h>

#include <data_caging_path_literals.hrh>

#include <gulicon.h>            // Gul Icon

#include <eikapp.h>

#include <eikenv.h>

#include <barsread.h>               // For TResourceReader

#include <bautils.h> 

#include <eikserverapp.h>

#include <aknappui.h>

#include <AknUtils.h>

#include <aknnotewrappers.h>

#include <hlplch.h>

#include "evteditor.h"

#include "evtmgmteditorui.hrh"

#include "evtevent.h"

#include "evttoneaction.h"

#include "evtdebug.h"

#include "evteditorconsts.h"

#include "evtmgmtuiringtonecomponent.h"

#include "evtdefs.h"

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

// CEvtEditor::NewL()

// @param[in] aIsEditMode - It sets mode of editor. 

//                          If true, edit mode is set else view mode is set. 

// @param[in] aEvent - The event to be displayed on editor

//                     Empty if new event is going to be created.

// @param[in] aTriggerLocation - Coordinate based location details of 

//                                  the event to be displayed on editor. 

// @param[in] aExitCmdHandler - It handles all commands which may result into closing editor.

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

//

CEvtEditor* CEvtEditor ::NewL(TBool                             aIsEditable, 

                             CEvtEvent&                         aEvent, 

                             CEvtMgmtUiEngine&                  aEventEngine,

                             TBool                              aDisplayExitMenuItem

                             )

    {

    CEvtEditor * self = new (ELeave) CEvtEditor(aIsEditable, aEvent, aEventEngine, aDisplayExitMenuItem );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CEvtEditor::~CEvtEditor()

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

//

CEvtEditor::~CEvtEditor()

    {  

	EVTUIDEBUG("+ CEvtEditor::~CEvtEditor()");

    // Close the resource loader

    iResourceLoader.Close();

    if(iCmdHandler)

        {

        delete iCmdHandler;

        iCmdHandler = NULL;

        }

    delete iSysOfMeas;

    iSysOfMeas = NULL;

	EVTUIDEBUG("- CEvtEditor::~CEvtEditor()");

    }

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

// CEvtEditor ::ConstructL()

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

//

void CEvtEditor ::ConstructL()

    {

	EVTUIDEBUG("+ CEvtEditor::ConstructL()");

    // Open the Resource File

    OpenLocalizedResourceFileL( KEvtEditorResFileName, iResourceLoader );

    CAknForm::ConstructL(R_EVTMGMTUI_CREATEEVENTFORM_MENUBAR);    

    iCmdHandler = CEvtMgmtUiEditorCmdHandler::NewL( iEvent, 

                                                    *this,

                                                    iEventEngine );

    // Observer for a change in System of Measurement

    iSysOfMeas = CEvtMgmtUiSysOfMeasurement::NewL(*this);

    }

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

// CEvtEditor ::CEvtEditor()

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

//

CEvtEditor::CEvtEditor( TBool                           aIsEditable, 

                        CEvtEvent&                      aEvent,

                        CEvtMgmtUiEngine&               aEventEngine,

                        TBool                           aDisplayExitMenuItem)

    :iIsEditMode( aIsEditable ), 

    iEvent( aEvent ), 

    iResourceLoader( *CCoeEnv::Static()),

    iEventEngine( aEventEngine ),

    iDisplayExitMenuItem( aDisplayExitMenuItem )

    {

    iEventAttributeMask = 0;

    }

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

// Derived from CEikDialog

// CEvtEditor ::OkToExitL()

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

//

TBool CEvtEditor::OkToExitL( TInt aButtonId )

    {

	EVTUIDEBUG1("+ CEvtEditor::OkToExitL() - %d", aButtonId );

    switch(aButtonId)

        {

        case EAknFormCmdEdit: // when MSK is pressed

            {

            //Handle MSK operation based on focused line.

            HandleMSKL(); 

            //dont close editor

            return EFalse;

            }

        case EAknSoftkeyOptions: //when LSK is pressed

            {

            //display menu specific to editor

            DisplayMenuL();

            //don't close editor

            return EFalse;

            }

        case EAknSoftkeyDone: // when RSK is pressed in edit mode

            {

            return ProcessDoneCommandL();

            }

        default: // close editor in all other cases

            {

            return ETrue;

            }

        }

    }

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

// CEvtEditor::ProcessDoneCommandL()

// It checks if event is empty.

// @ret true if event is empty else false

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

//

TBool CEvtEditor::ProcessDoneCommandL()

    {                

    //validate event, if valid event, display 'Event status' popup dialog

    // and perform selected operation.          

    if( IsEmptyEventL() || !iEventAttributeMask )

        {

        return ETrue;

        }                

    else

        {

        //update attribute mask so that only those attributes of event will be modified                    

        iCmdHandler->SetEventAttributeMask( iEventAttributeMask );

        if(EActive == iEvent.EventStatus())

            {

            if(MandatoryFieldsFilled())

                {

                iCmdHandler->HandleEditorCmdL( EEvtEditorCmdActivate );

                }

            else

                {

                HBufC* infoMsg = StringLoader::LoadLC(R_LOCEV_NOTE_MISSED_INFO );

                CAknInformationNote* infoNote = new(ELeave) CAknInformationNote( ETrue );

                infoNote->ExecuteLD( *infoMsg  );

                CleanupStack::PopAndDestroy();

                }

            }

        else

            {

            iCmdHandler->HandleEditorCmdL( EEvtEditorCmdSaveDraft );

            }

        return EFalse;

        }

    }

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

// CEvtEditor::IsEmptyEventL()

// It checks if event is empty.

// @ret true if event is empty else false

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

//

TBool CEvtEditor::IsEmptyEventL()

    {    

    //if eventid is not zero, it means existing event is opened in editor

    //hence it is not empty event.

    if(iEvent.EventId())

        return EFalse;

    // Check for Default Action

    TBool defaultAction(EFalse);

    if( iEvent.HasAction() )

        {            

        CEvtToneAction* tone = CEvtToneAction::NewLC();  

        tone->InternalizeL( iEvent.Action() );  

        CEvtMgmtUiRingtoneComponent* ringtoneComponent = CEvtMgmtUiRingtoneComponent::NewLC( KNullDesC() );

        if( ringtoneComponent->DefaultRingtoneL().Compare( tone->FileName() ) == 0 && 

                !tone->ToneLoop() )

            {

            defaultAction = ETrue;

            }

        CleanupStack::PopAndDestroy( 2 ); // tone, ringtoneComponent

        }

    //if eventid is zero, it means new event is about to create.

    //hence check if something is entered by the user.    

    if( 6 == GetNumberOfLinesOnPage(0) && //if only subject,place and repeat are present

        0 == iEvent.Subject().Compare(KNullDesC) && //if subject is empty

        0 == iEvent.Place().Compare(KNullDesC) && // if place is default

        0 == iEvent.Repeat() && // if repeat is OFF

        EDraft == iEvent.EventStatus() &&

        defaultAction ) // if Status is Draft

        {       

        return ETrue; 

        }  

    return EFalse;

    }

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

// CEvtEditor ::LoadFormValuesFromDataL()

// Called when the form is  executed and when the user chooses to discard changes

// in QuerySaveChangesL (via  DoNotSaveFormDataL).

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

// 

void CEvtEditor::LoadFormValuesFromDataL()

    {

	EVTUIDEBUG("+ CEvtEditor::LoadFormValuesFromDataL()");

    if(iEvent.EventId()==0) //if create event

        {

        CEikEdwin* placeEditor = static_cast <CEikEdwin*> (ControlOrNull(EEvtMgmtUiDlgCIdPlace));            

            if(placeEditor)

                {   

                if( iEvent.Place().Compare(KNullDesC) == 0 )  

                    {

                    HBufC* define = StringLoader::LoadLC(R_EVTUI_CREATENEW_FORM_DEFINED);   

                    placeEditor->SetTextL(define);

                    CleanupStack::PopAndDestroy(define);

                    }               

                } 

        CAknPopupFieldText* repeatPopupFieldText = (CAknPopupFieldText*)Control( EEvtMgmtUiDlgCIdRepeat );

            if(repeatPopupFieldText)

                {  

                repeatPopupFieldText->SetCurrentValueIndex(1);      

                }

        // Set the Default Ringtone

        CEvtMgmtUiRingtoneComponent* ringtoneComponent = CEvtMgmtUiRingtoneComponent::NewLC( KNullDesC() );

        if( ringtoneComponent->DefaultRingtoneL().Compare( KNullDesC ) == 0 )

            {

            iEvent.SetActionL( NULL );

            }

        else

            {

            CEvtToneAction* tone = CEvtToneAction::NewLC();

            tone->SetFileNameL( ringtoneComponent->Ringtone() );

            tone->SetToneLoop( EFalse );  

            CEvtAction* action = CEvtAction::NewLC();

            tone->ExternalizeL( *action );

            iEvent.SetActionL( action ); // ownership is transferred.

            CleanupStack::Pop( action ); // action  

            CleanupStack::PopAndDestroy( ); // tone        

            }

        CleanupStack::PopAndDestroy( ); // ringtoneComponent   

        SetRingtoneL();

        // Set Default Status

        iEvent.SetEventStatus(EDraft);

        SetStatusL();

        return;

        }

   //assign initial values

   	CEikEdwin* subjectEditor = static_cast <CEikEdwin*> (ControlOrNull(EEvtMgmtUiDlgCIdSubject));

    if(subjectEditor )

        {        

		if( iEvent.Subject().Compare(KNullDesC) != 0 )

			{

			HBufC* subject = iEvent.Subject().AllocLC();   

			subjectEditor->SetTextL( subject );

			CleanupStack::PopAndDestroy(subject);

			}

        }

    CEikEdwin* placeEditor = static_cast <CEikEdwin*> (ControlOrNull(EEvtMgmtUiDlgCIdPlace));            

    if(placeEditor)

        {   

        if( iEvent.Place().Compare(KNullDesC) == 0 )  

	        {

			HBufC* define = StringLoader::LoadLC(R_EVTUI_CREATENEW_FORM_DEFINED);   

			placeEditor->SetTextL(define);

			CleanupStack::PopAndDestroy(define);

	        }

	    else

		    {

			HBufC* place = iEvent.Place().AllocLC();   

			placeEditor->SetTextL(place);

			CleanupStack::PopAndDestroy(place);

            EVTUIDEBUG(" Setting Radius");

            InsertRadiusDlgLineL();

		    }

	    }     

    CAknPopupFieldText* repeatPopupFieldText = (CAknPopupFieldText*)Control( EEvtMgmtUiDlgCIdRepeat );

    if(repeatPopupFieldText)

        {    

        if(iEvent.Repeat())

            repeatPopupFieldText->SetCurrentValueIndex(0);

         else

             repeatPopupFieldText->SetCurrentValueIndex(1);      

        }

    // Set Ringtone

    SetRingtoneL();

    // Set Status

    SetStatusL();

    if( iEvent.Description().Compare(KNullDesC)!=0 )

        {

        InsertDesDlgLineL();

        SetDescL();

        }

	EVTUIDEBUG("- CEvtEditor::LoadFormValuesFromDataL()");

    }

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

// Derived from CEikDialog

// CEvtEditor ::PreLayoutDynInitL()

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

// 

void CEvtEditor::PreLayoutDynInitL()

    {

	EVTUIDEBUG("+ CEvtEditor::PreLayoutDynInitL()");

    CAknForm::PreLayoutDynInitL();

    //Load existing event if it is opened in viewe mode  

    LoadFormValuesFromDataL();

	EVTUIDEBUG("- CEvtEditor::PreLayoutDynInitL()");

    }

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

// Derived from CEikDialog

// CEvtEditor ::PostLayoutDynInitL()

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

// 

void CEvtEditor::PostLayoutDynInitL()

    {

	EVTUIDEBUG("+ CEvtEditor::PostLayoutDynInitL()");

   CAknForm::PostLayoutDynInitL();

     if(iEvent.Subject().Compare(KNullDesC) == 0)

        {

        if(iEvent.EventId())

            {

            TPtrC ptr = KNullDesC();

            MakeTitleL(ptr);  

            }

        else

            {

            HBufC* navititle = StringLoader::LoadLC( R_EVTUI_CREATENEW_FORM_DEFAULTNAVITITLE);

            MakeTitleL(*navititle);  

            CleanupStack::PopAndDestroy(navititle);

            }

        }

    else

        {

        TPtrC ptr = iEvent.Subject();

        MakeTitleL( ptr);

        }

    ChangeRSKCaptionL();

    SetEditableL(iIsEditMode);

	EVTUIDEBUG("- CEvtEditor::PostLayoutDynInitL()");

    }

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

// Derived from CAknForm

// CEvtEditor ::DynInitMenuPaneL()

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

//  

void CEvtEditor ::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* aMenuPane)

    {

    CAknForm::DynInitMenuPaneL(aResourceId,aMenuPane);

    if (aResourceId == R_AVKON_FORM_MENUPANE)

        {  

        // Disable all the unwanted AKnForm's Default Menu Items 

        aMenuPane->SetItemDimmed(EAknFormCmdLabel, ETrue);

        aMenuPane->SetItemDimmed(EAknFormCmdAdd, ETrue);

        aMenuPane->SetItemDimmed(EAknFormCmdDelete, ETrue);

        aMenuPane->SetItemDimmed(EAknFormCmdSave, ETrue);

        if(iDisplayExitMenuItem)

            aMenuPane->SetItemDimmed(EAknCmdExit, EFalse);

        else

            aMenuPane->SetItemDimmed(EAknCmdExit, ETrue);

        if( IsEditable() )

	        {

	        // "Edit" present only in Viewer mode

	        aMenuPane->SetItemDimmed(EAknFormCmdEdit, ETrue);

	        // "Discard Changes" has to be present only in Edit mode

	        // and if some changes are made

	        if( IsEmptyEventL() || !iEventAttributeMask || !iEvent.EventId())

	            aMenuPane->SetItemDimmed(EEvtEditorCmdDiscard, ETrue);

	        else

                aMenuPane->SetItemDimmed(EEvtEditorCmdDiscard, EFalse);

            // Initially display all the Editor specific Menu items which 

            // are dimmed based on focus and context

			aMenuPane->SetItemDimmed(EEvtEditorCmdAddDesc, ETrue);

			aMenuPane->SetItemDimmed(EEvtEditorCmdRemoveDesc, ETrue);

			aMenuPane->SetItemDimmed(EEvtEditorCmdSetPlace, ETrue);

			aMenuPane->SetItemDimmed(EEvtEditorCmdEditDesc, ETrue);

			if(NULL == ControlOrNull(EEvtMgmtUiDlgCIdAssignTone))

			    aMenuPane->SetItemDimmed(EEvtEditorCmdAssignTone, EFalse);

			else

			    aMenuPane->SetItemDimmed(EEvtEditorCmdAssignTone, ETrue);

	        // "Add Description" / "Remove Description" is displayed based

	        // on Decsription control's existance in Form

	        if( NULL == ControlOrNull(EEvtMgmtUiDlgCIdDesc) )

	            {

	            aMenuPane->SetItemDimmed(EEvtEditorCmdAddDesc, EFalse);

	        	aMenuPane->SetItemDimmed(EEvtEditorCmdRemoveDesc, ETrue);

	            }

	        else

	            {

	            aMenuPane->SetItemDimmed(EEvtEditorCmdAddDesc, ETrue);

	        	aMenuPane->SetItemDimmed(EEvtEditorCmdRemoveDesc, EFalse);

	            }

	        // Menu items whose existance depends on the focussed control

	        switch( IdOfFocusControl() )

	            {

	            case EEvtMgmtUiDlgCIdPlace:

	                {

	                aMenuPane->SetItemDimmed(EEvtEditorCmdSetPlace, EFalse);

	                break;

	                }

	            case EEvtMgmtUiDlgCIdDesc:            

	                {

	                aMenuPane->SetItemDimmed(EEvtEditorCmdEditDesc, EFalse);

	                break;

	                }    

	            case EEvtMgmtUiDlgCIdAssignTone:              

	                {

	                aMenuPane->SetItemDimmed(EAknFormCmdEdit, ETrue);

	                aMenuPane->SetItemDimmed(EEvtEditorCmdAssignTone, EFalse);

	                break;

	            case EEvtMgmtUiDlgCIdRepeat:

	            case EEvtMgmtUiDlgCIdAudioLoop:   

	                {

	            default:

	                {

	                break;

	                }                

	            }//switch

            // Activate and Draft are absent in Edit mode

            aMenuPane->SetItemDimmed(EEvtEditorCmdActivate, ETrue);

            aMenuPane->SetItemDimmed(EEvtEditorCmdSaveDraft, ETrue);

	        // Editor/Viewer specific menu items    

    		aMenuPane->SetItemDimmed(EEvtEditorCmdNavigateToPlace, ETrue);

    		aMenuPane->SetItemDimmed(EEvtEditorCmdShowOnMap, ETrue);

    		aMenuPane->SetItemDimmed(EEvtMgmtUiEventUiPosSettings, EFalse);

	        }

	    else   // View Mode

	        {

	        // "Edit" present only in Viewer mode

	        aMenuPane->SetItemDimmed(EAknFormCmdEdit, EFalse);

            // "Discard Changes" has to be absent only in View mode