/*

* 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 : calendar unified editor fields control

*

*/

// system includes

#include <eikedwin.h>

#include <eikmfne.h>

#include <StringLoader.h>

#include <e32des16.h>

#include <calentry.h>

#include <CalenDefaultEditorsData.rsg>

#include <calendateutils.h>

#include <calenservices.h>

// user includes

#include "calenunifiededitorcontrol.h"

#include "calenunifiededitor.h"

#include "CalenDefaultEditors.hrh"

#include "calenentryutil.h"

#include "caleneventtypefield.h"

#include "calenreminderfield.h"

#include "calenrepeatfield.h"

#include "calenalldayfield.h"

#include "calenpriorityfield.h"

#include "calendbfield.h"

#include "CalenDescription.h"

// debug

#include "calendarui_debug.h"

// Constants

const TInt KOneDay( 1 );

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

// CCalenUnifiedEditorControl::NewL

// Two phased constructor

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

//

CCalenUnifiedEditorControl* CCalenUnifiedEditorControl::NewL( CCalenUnifiedEditor& aUnifiedEditor,

                                                    MCalenServices& aServices )

    {

    TRACE_ENTRY_POINT;

    CCalenUnifiedEditorControl* self = new (ELeave)CCalenUnifiedEditorControl( aUnifiedEditor );

    CleanupStack::PushL( self );

    self->ConstructL(aServices);

    CleanupStack::Pop();

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenUnifiedEditorControl::CCalenUnifiedEditorControl

// Destructor

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

//

CCalenUnifiedEditorControl::~CCalenUnifiedEditorControl()

    {

    TRACE_ENTRY_POINT;

    delete iEventTypeField;

    delete iReminderField;

    delete iRepeatField;

    delete iAllDayField;

    delete iPriorityField;

    delete iDbField;

    delete iDescription;

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditorControl::ConstructL

// Second phased construction

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

//

void CCalenUnifiedEditorControl::ConstructL(MCalenServices& aServices)

    {

    TRACE_ENTRY_POINT;

    iEventTypeField = CCalenEventTypeField::NewL( iUnifiedEditor );

    iReminderField = CCalenReminderField::NewL( iUnifiedEditor );

    iRepeatField = CCalenRepeatField::NewL( iUnifiedEditor );

    iAllDayField = CCalenAllDayField::NewL( iUnifiedEditor );

    iPriorityField = CCalenPriorityField::NewL( iUnifiedEditor );

    iDbField = CCalenDbField::NewL( iUnifiedEditor,aServices );

    iDescription = CCalenDescription::NewL( iUnifiedEditor );

    TRACE_EXIT_POINT;    

    }

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

// CCalenUnifiedEditorControl::CCalenUnifiedEditorControl

// Default constructor

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

//

CCalenUnifiedEditorControl::CCalenUnifiedEditorControl( CCalenUnifiedEditor& aUnifiedEditor )

    :iUnifiedEditor( aUnifiedEditor )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditorControl::MakeUnifiedEditorL

// Initializes the dialog's controls before the dialog is sized

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

//

void CCalenUnifiedEditorControl::MakeUnifiedEditorL()

    {

    TRACE_ENTRY_POINT;

    // Add default editor fields.

    AddDefaultEditorL();

    // Initialise editor fields.

    InitDefaultEditorsL();

    // Set data to editor fields.

    SetDataToEditorL();

    // Update MSK string.

    iUnifiedEditor.SetMskFromResourceL();

    iUnifiedEditor.UpdateFormL();

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditorControl::SetDataToEditorL

// Set data to the collapsed unified editor

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

//

void CCalenUnifiedEditorControl::SetDataToEditorL(TBool onLocaleUpdate)

    {

    TRACE_ENTRY_POINT;

    // Set Editor field values

    // Set data to EventType fields   

    iEventTypeField->SetDataToEditorL();

    TPtrC subject = iUnifiedEditor.Edited().Summary().Left(

                        iUnifiedEditor.MaxTextEditorLength() );

    if(!onLocaleUpdate)

        iUnifiedEditor.SetEditorTextL( ECalenEditorSubject, &subject );

    // update duration for EndTime update, with StartTime change

    UpdateMeetingDurationL();

    switch( iUnifiedEditor.GetEntryType() )

        {

        case CCalEntry::EEvent:

            {

              iAllDayField->SetDataToEditorL();

            }

            break;

        case CCalEntry::EAnniv:

            {

            TTime birthDayYear = iUnifiedEditor.Edited().EventDateTime();

            SetDateField( ECalenEditorStartDate, birthDayYear, ETrue );

            }

            break;

        case CCalEntry::EAppt:

            {

            if( iUnifiedEditor.Edited().IsAllDayEvent() )

                {

                iAllDayField->SetDataToEditorL();

                }

            else

                {

                // Entry is Non-AllDay event

                TTime firstRDate; 

                TTime rruleEndTime ;             

                TTimeIntervalMinutes duration;                

                TTime entryStartTime = iUnifiedEditor.Edited().StartDateTime();

                TTime entryEndTime = iUnifiedEditor.Edited().EndDateTime();

                User::LeaveIfError( entryEndTime.MinutesFrom( entryStartTime, duration ) );

                ReadRruleL(firstRDate,rruleEndTime);                                           

                if( firstRDate <= entryStartTime)

                    {                    

                    SetTimeField( ECalenEditorStartTime, firstRDate, ETrue );

                    SetTimeField( ECalenEditorEndTime, rruleEndTime, ETrue );                

                    SetDateField( ECalenEditorStartDate, firstRDate, ETrue);

                    SetDateField( ECalenEditorEndDate, rruleEndTime, ETrue);

                    }

                else{

                    SetTimeField( ECalenEditorStartTime, entryStartTime, ETrue );

                    SetTimeField( ECalenEditorEndTime, entryEndTime, ETrue );                

                    SetDateField( ECalenEditorStartDate, entryStartTime, ETrue);

                    SetDateField( ECalenEditorEndDate, entryEndTime, ETrue);

                    }                

               }

            }

            break;

        case CCalEntry::ETodo:

            {

            TTime dueDate = iUnifiedEditor.Edited().EventDateTime();

            // update date field with todays date

            SetDateField(ECalenEditorStartDate, dueDate, ETrue);

            // set priority field value 

            iPriorityField->SetDataToEditorL();

            }

            break;

        default:

            break;

        }

    iReminderField->SetDataToEditorL();

    // Anniversary, To-do, exceptional and single instance of repeat entry 

    // do not have Repeat field.

    if( CCalEntry::EAnniv != iUnifiedEditor.GetEntryType()

            && CCalEntry::ETodo != iUnifiedEditor.GetEntryType() )

        {

        iRepeatField->SetDataToEditorL();

        }

    if(!iDbField->IsCalendarEdited())

        {

        iDbField->SetDataToEditorL();

        }

    if( CCalEntry::ETodo != iUnifiedEditor.GetEntryType() )

        {

        TPtrC location = iUnifiedEditor.Edited().Location().Left(

                            iUnifiedEditor.MaxTextEditorLength() );

        if(!onLocaleUpdate)

            iUnifiedEditor.SetEditorTextL( ECalenEditorPlace, &location );

        }

    // TODO: Uncomment this when enabling attachment support

      iUnifiedEditor.SetAttachmentNamesToEditorL();

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditorControl::AddDefaultEditorL

// Adds editor fields

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

//

void CCalenUnifiedEditorControl::AddDefaultEditorL()

    {

    TRACE_ENTRY_POINT;

    switch( iUnifiedEditor.GetEntryType() )

        {

        case CCalEntry::EEvent:

            {

            AddDefaultMeetingEditorL();

            }

            break;

        case CCalEntry::EAnniv:

            {

            AddDefaultBirthDayEditorL();

            }

            break;            

        case CCalEntry::EAppt:

            {

            AddDefaultMeetingEditorL();

            }

            break;

        case CCalEntry::ETodo:

            {

            AddDefaultTodoEditorL();

            }            

            break;

        default:

            break;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditorControl::InitDefaultEditorsL

// Initialise default editor contents

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

//

void CCalenUnifiedEditorControl::InitDefaultEditorsL()

    {

    TRACE_ENTRY_POINT;

    // Set editor lengths

    CEikEdwin* edwin = static_cast<CEikEdwin*>( iUnifiedEditor.Control( ECalenEditorSubject ) );

    edwin->SetTextLimit( iUnifiedEditor.MaxTextEditorLength() );

    iEventTypeField->InitEventTypeFieldLayoutL();

    //Currently nothig to be initalized 

    //as its intial value depend on entry

    iAllDayField->InitAllDayFieldLayoutL();

    iReminderField->InitReminderFieldLdayoutL();

    // To Initialise priority field for meeting tyrpe entry

    if( CCalEntry::ETodo == iUnifiedEditor.GetEntryType() )

        {

        iPriorityField->InitPriorityFieldLayoutL();

        }

    // Initialise repeat field, if it's not Anniversary.

    // To-do entry don't have repeat field, for now

    if( CCalEntry::EAnniv != iUnifiedEditor.GetEntryType() && 

                CCalEntry::ETodo != iUnifiedEditor.GetEntryType() )

        {

        iRepeatField->InitRepetFieldLayoutL();

        }

    RPointerArray<CCalCalendarInfo> calendarInfoList; 

    iUnifiedEditor.GetServices().GetAllCalendarInfoL(calendarInfoList);

    CleanupClosePushL( calendarInfoList );

    if( calendarInfoList.Count() > 1 )

      {

        iDbField->InitDbFieldLayoutL();

      }

    CleanupStack::PopAndDestroy( &calendarInfoList );

    iDescription->InitDescritpionFieldLayoutL();

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditorControl::AddDefaultBirthDayEditorL

// Add collapsed birthday editor contents

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

//

void CCalenUnifiedEditorControl::AddDefaultBirthDayEditorL()

    {

    TRACE_ENTRY_POINT;

    // event type, subject, date & year,more details

    else

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_PLACE_ITEM,

                    ECalenEditorPlace, ECalenEditorReminder );

    // TODO: Uncomment this when enabling attachment support

    // Replace ECalenEditorDBName with ECalenEditorAttachment in the next statement

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_ATTACHMENT_ITEM,

                    ECalenEditorAttachment, ECalenEditorPlace );

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_DESCRIPTION_ITEM,

                    ECalenEditorDescription, ECalenEditorAttachment );

    iUnifiedEditor.UpdateFormL();

    TRACE_EXIT_POINT;

    }

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

// CCalenUnifiedEditorControl::AddDefaultMeetingEditorL

// Add meeting editor contents

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

//

void CCalenUnifiedEditorControl::AddDefaultMeetingEditorL()

    {

    TRACE_ENTRY_POINT;

    // non all day event 

    // event type,subject,all day,start time,end time,start date,

    // end date,place,more details

    // all day event 

    // subject,event type,all day,start date,end date,place,more details 

    RPointerArray<CCalCalendarInfo> calendarInfoList; 

    iUnifiedEditor.GetServices().GetAllCalendarInfoL(calendarInfoList);

    CleanupClosePushL( calendarInfoList );

    if( calendarInfoList.Count() > 1 )

        {

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_DB_NAME_ITEM,

            ECalenEditorDBName, ECalenEditorSubject );

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_ALL_DAY_ITEM,

            ECalenEditorAllDayItem, ECalenEditorDBName );

        }

    else

        {

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_ALL_DAY_ITEM, 

            ECalenEditorAllDayItem, ECalenEditorSubject );

        }

    CleanupStack::PopAndDestroy( &calendarInfoList );

    if( !iUnifiedEditor.Edited().IsAllDayEvent() )

        {

        iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_START_TIME_ITEM, 

                ECalenEditorStartTime, ECalenEditorAllDayItem );

        iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_END_TIME_ITEM,

                ECalenEditorEndTime, ECalenEditorStartTime );

        iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_START_DATE_ITEM,

                    ECalenEditorStartDate, ECalenEditorEndTime );        

        }

     else

         {

         iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_START_DATE_ITEM,

                     ECalenEditorStartDate, ECalenEditorAllDayItem );   

         }

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_END_DATE_ITEM,

            ECalenEditorEndDate, ECalenEditorStartDate );

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_PLACE_ITEM,

                  ECalenEditorPlace, ECalenEditorEndDate );

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_REMINDER_ITEM,

                    ECalenEditorReminder, ECalenEditorPlace );

    iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_REPEAT_ITEM,

                    ECalenEditorRepeat, ECalenEditorReminder );

    /*iUnifiedEditor.InsertFieldL( R_CALEN_EDITOR_PEOPLE_ITEM,

                    ECalenEditorPeople, ECalenEditorRepeat );

    */