--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/calendarui/editors/src/CalenEditorDataHandler.cpp Wed Sep 01 12:32:31 2010 +0100
@@ -0,0 +1,3076 @@
+/*
+* Copyright (c) 2006 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: CalenEditorDataHandler implements all logic of checking and
+* validating editor data
+*
+*/
+
+// System includes
+#include <calendateutils.h>
+#include <calenagendautils.h>
+#include <calinstance.h>
+#include <calalarm.h>
+#include <calentry.h>
+#include <calrrule.h>
+#include <centralrepository.h>
+#include <calattachment.h>
+#include <eikenv.h>
+#include <CalenInterimUtils2.h>
+#include <calencontext.h>
+#include <caleninstanceid.h> // TCalenInstanceId
+#include <calenservices.h>
+
+// User includes
+#include "CalenEditorDataHandler.h"
+#include "CalendarPrivateCRKeys.h"
+#include "CalenDefaultEditors.hrh"
+#include "calenentryutil.h"
+#include "CleanupResetAndDestroy.h"
+#include "calenattachmentutils.h"
+#include "calenattachmentinfo.h"
+#include "calenattachmentmodel.h"
+#include "calenunifiededitor.h"
+#include "calendarui_debug.h"
+
+// Constants
+#define KNoOfDaysInWeek 7
+
+// ======== LOCAL FUNCTIONS ========
+
+// -----------------------------------------------------------------------------
+// IsTimed
+// Returns ETrue if the entry is timed (i.e. an appointment or a
+// reminder), EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+static TBool IsTimed( CCalEntry::TType aEntryType )
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return aEntryType == CCalEntry::EAppt || aEntryType == CCalEntry::EReminder;
+ }
+
+// -----------------------------------------------------------------------------
+// ForeverDate
+// Returns the date which Calendar presumes to be infinitely far in the future.
+// Used, for example, when setting a repeating meeting to repeat forever.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+static TTime ForeverDate()
+ {
+ TRACE_ENTRY_POINT;
+
+ TTime forever = TTime( TDateTime( ECalenForeverYear, static_cast<TMonth>( ECalenForeverMonth ),
+ ECalenForeverDay, 0, 0, 0, 0) );
+
+ TRACE_EXIT_POINT;
+ return forever;
+ }
+
+// -----------------------------------------------------------------------------
+// IsForeverDate
+// Returns ETrue if the given date is considered by Calendar to be infinitely
+// far in the future.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+static TBool IsForeverDate( const TTime& aDate )
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return CalenDateUtils::OnSameDay( aDate, ForeverDate() );
+ }
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::CCalenEditorDataHandler
+// Constructor.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CCalenEditorDataHandler::CCalenEditorDataHandler(
+ CCalEntry& aEntry,
+ const TCalTime& aInstanceDateTime,
+ TBool aIsCreatingNew,
+ TInt aMaxTextEditorLength,
+ MCalenServices& aServices,
+ RArray<TInt>& aCollectionIds)
+ : iEntry( aEntry ),
+ iInstanceDateTime( aInstanceDateTime ),
+ iIsCreatingNew( aIsCreatingNew ),
+ iMaxTextEditorLength( aMaxTextEditorLength ),
+ iServices( aServices ) , iCalendarFieldEdited(EFalse) , iCollectionIds(aCollectionIds)
+ {
+ TRACE_ENTRY_POINT;
+ TRACE_EXIT_POINT;
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::ConstructL
+// Two phase construction.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::ConstructL()
+ {
+ TRACE_ENTRY_POINT;
+
+ iEntryType = iEntry.EntryTypeL();
+ iRecurrenceId = iEntry.RecurrenceIdL();
+
+ iOriginal = CCalenEntryUtil::NewL( iEntry, iInstanceDateTime );
+ iEdited = CCalenEntryUtil::NewL( iEntry, iInstanceDateTime );
+ if ( IsCreatingNew() )
+ {
+ SetDefaultNewValuesL( *iOriginal ); // modify iOriginal also
+ SetDefaultNewValuesL( *iEdited );
+ }
+ else
+ {
+ iInstanceId = iServices.Context().InstanceId();
+ }
+
+
+ TRACE_EXIT_POINT;
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::NewL
+// Two-phased constructor.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CCalenEditorDataHandler* CCalenEditorDataHandler::NewL(
+ CCalEntry& aEntry,
+ const TCalTime& aInstanceDateTime,
+ TBool aIsCreatingNew,
+ TInt aMaxTextEditorLength,
+ MCalenServices& aServices,
+ RArray<TInt>& aCollectionIds)
+ {
+ TRACE_ENTRY_POINT;
+
+ CCalenEditorDataHandler* self = new( ELeave ) CCalenEditorDataHandler(
+ aEntry, aInstanceDateTime, aIsCreatingNew, aMaxTextEditorLength, aServices,aCollectionIds );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ TRACE_EXIT_POINT;
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::~CCalenEditorDataHandler
+// Destructor.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CCalenEditorDataHandler::~CCalenEditorDataHandler()
+ {
+ TRACE_ENTRY_POINT;
+
+ delete iOriginal;
+ delete iEdited;
+
+ TRACE_EXIT_POINT;
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::Edited
+// Returns the CCalenEditorDataHandler used to represent the entry the
+// user is currently editing.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CCalenEntryUtil& CCalenEditorDataHandler::Edited()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return *iEdited;
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::Original
+// Returns the CCalenEditorDataHandler used to represent the entry the
+// user originally opened.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+const CCalenEntryUtil& CCalenEditorDataHandler::Original() const
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return *iOriginal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::Entry
+// Returns the entry this object is wrapping round.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CCalEntry& CCalenEditorDataHandler::Entry()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return iEntry;
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::InstanceDateTime
+// Returns the instance date/time.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+const TCalTime& CCalenEditorDataHandler::InstanceDateTime() const
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return iInstanceDateTime;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::ShouldSaveOrDeleteOrDoNothingL
+// Works out whether the entry should be deleted, saved,
+// or whether no action should be taken.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CCalenEditorDataHandler::TAction CCalenEditorDataHandler::ShouldSaveOrDeleteOrDoNothingL()
+ {
+ TRACE_ENTRY_POINT;
+
+ if ( !IsEditedL() )
+ {
+ // Not edited at all OR
+ // Only added space characters to text fields but not
+ // edited the non-text fields
+ // no need to save the note
+ TRACE_EXIT_POINT;
+ return CCalenEditorDataHandler::EActionNothing;
+ }
+
+ // *************** THE NOTE IS EDITED ********************
+ if(IsCreatingNew())
+ {
+ // ************* EDITED NEW NOTE *********
+
+ // Subject && Location && Description are text fields
+ // If text fields as a whole is not empty, we can save the note
+ // If text fields as a whole IS empty, we can STILL save the note
+ // since we edited "non-text" fields
+ if ( !NonTextFieldsEditedL() && AreTextFieldsEmptyL() )
+ {
+ TRACE_EXIT_POINT;
+ return CCalenEditorDataHandler::EActionNothing;
+ }
+ else
+ {
+ TRACE_EXIT_POINT;
+ return CCalenEditorDataHandler::EActionSave;
+ }
+ }
+
+ // **************** EDITED OLD NOTE **********
+
+ if(AreTextFieldsClearedL() && !NonTextFieldsEditedL()) // subject && location && description
+ {
+ // ***** OLD NOTE + TEXT FIELDS EMPTIED + NON-TEXT FIELDS NOT EDITED
+ // Even if user may have edited non-text fields,
+ // delete the note
+ TRACE_EXIT_POINT;
+ return CCalenEditorDataHandler::EActionDelete;
+ }
+
+ // ****** OLD NOTE WITH TEXT FIELDS **********
+ // Save the note, since the text fields contain something
+ TRACE_EXIT_POINT;
+ return CCalenEditorDataHandler::EActionSave;
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::NonTextFieldsEdited
+// Returns ETrue if any of the non-text fields (e.g. time fields) of the entry
+// have been edited, EFalse otherwise.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::NonTextFieldsEditedL()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+
+ return ( IsStartDateTimeEdited() ||
+ IsEndDateTimeEdited() ||
+ IsAlarmEditedL() ||
+ IsRepeatRuleEdited() ||
+ IsPriorityEdited() ||
+ IsCalendarEditedL() ||
+ IsAttachmentExists() ||
+ IsEventTypeEdited() ||
+ AllDayFieldEdited() );
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::TextFieldsEdited
+// Returns ETrue if any of the text fields (e.g. summary) of the entry
+// have been edited, EFalse otherwise.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::TextFieldsEdited()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+
+ return ( IsSummaryEdited() || IsLocationEdited() || IsDescriptionEdited()
+ || IsAttachmentExists() );
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsEditedL
+// Returns ETrue if the entry has been modified, EFalse otherwise.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsEditedL()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+
+ return ( TextFieldsEdited() || NonTextFieldsEditedL() );
+ }
+
+// ---------------------------------------------------------------------------
+// CCalenEditorDataHandler::WriteChangesToEntryL
+// Read the data from the form and set it to the entry.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::WriteChangesToEntryL( CalCommon::TRecurrenceRange aRepeatTarget )
+ {
+ TRACE_ENTRY_POINT;
+
+ // This is only place where we can read data from CCalEntry.
+ // E.g. when we calculate alarm offset, we need to read start time from
+ // entry, not anymore from CCalenEntryUtil.
+ TBool isNew = IsCreatingNew();
+
+ WriteStartAndEndTimesToEntryL( aRepeatTarget );
+
+ if ( isNew || IsSummaryEdited() )
+ {
+ TPtrC summary = Edited().Summary();
+ // If text is considered empty, always store as KNullDesC
+ if ( CalenAgendaUtils::IsEmptyText( summary ) )
+ {
+ summary.Set( KNullDesC );
+ }
+ iEntry.SetSummaryL( summary );
+ }
+
+ if ( isNew || IsLocationEdited() )
+ {
+ TPtrC location = Edited().Location();
+ // If text is considered empty, always store as KNullDesC
+ if ( CalenAgendaUtils::IsEmptyText( location ) )
+ {
+ location.Set(KNullDesC);
+ }
+ iEntry.SetLocationL( location );
+ }
+
+ if ( isNew || IsDescriptionEdited() )
+ {
+ iEntry.SetDescriptionL( Edited().Description() );
+ }
+
+ // Repeat rule has to be modified in both cases
+ if ( isNew || IsStartDateTimeEdited() || IsRepeatRuleEdited() )
+ {
+
+ if ( aRepeatTarget == CalCommon::EThisOnly)
+ {
+ iEntry.ClearRepeatingPropertiesL();
+ }
+ else if ( Edited().IsRepeating() )
+ {
+ // If we're an RDate (with repeat type ERepeatOther), don't try to set an RRule,
+ // but don't clear the repeat properties either.
+ if( Edited().RepeatType() != ERepeatOther )
+ {
+ TCalRRule rrule;
+
+ CalculateRepeatRuleL( Edited().StartDateTime(),
+ Edited().RepeatType(),
+ Edited().RepeatUntilDateTime(),
+ rrule );
+
+ iEntry.SetRRuleL( rrule );
+
+ // As there should not be any rdates, remove any that are
+ // still present
+ RArray<TCalTime> emptyList;
+ CleanupClosePushL( emptyList );
+ iEntry.SetRDatesL( emptyList );
+ CleanupStack::PopAndDestroy(); // emptyList
+ }
+ else
+ {
+ // The repeat type is ERepeatOther, therefore as
+ // it is impossible to create an entry of type
+ // ERepeat other using the editor either the repeat until
+ // date or the start date must have been changed
+
+ // The start date/time has changed, in order for the
+ // series to maintain its pattern, any rDates and if
+ // present rRule are moved by the same offset
+ // The repeat type is ERepeatOther, so check if we have any rdates
+ RArray<TCalTime> rDateList;
+ CleanupClosePushL( rDateList );
+ iEntry.GetRDatesL( rDateList );
+ TInt count = rDateList.Count();
+
+ if ( count == 0 )
+ {
+ // There are no rdates so the new until and start date can be applied
+ // directly.
+ TCalRRule rrule;
+
+ CalculateRepeatRuleL( Edited().StartDateTime(),
+ Edited().RepeatType(),
+ Edited().RepeatUntilDateTime(),
+ rrule );
+
+ iEntry.SetRRuleL( rrule );
+ }
+ else
+ {
+ // There are rDates which need to be checked.
+ if ( IsStartDateTimeEdited() )
+ {
+ // Need to shift any rdates
+ TTime editedStart = iEdited->StartDateTime();
+ TTime origStart = iOriginal->StartDateTime();
+ TTimeIntervalMicroSeconds offSet = editedStart.MicroSecondsFrom( origStart );
+ for ( TInt index = 0; index < count; index++ )
+ {
+ TCalTime& rDateTime = rDateList[ index ];
+ TTime shiftedTime = rDateTime.TimeUtcL();
+ TDateTime before = shiftedTime.DateTime();
+ shiftedTime += offSet;
+ TDateTime after = shiftedTime.DateTime();
+ rDateTime.SetTimeUtcL( shiftedTime );
+ }
+ }
+
+ // Check and fix the rDates and rRules match the
+ // repeat until date and time.
+ TTime untilTime = Edited().RepeatUntilDateTime();
+
+ // Remove any rdates that are after the the repeat until date
+ TInt count = rDateList.Count();
+ if ( count > 0 )
+ {
+ TInt index = count - 1;
+ do
+ {
+ TTime lastRDate = CalenDateUtils::BeginningOfDay( rDateList[ index ].TimeLocalL() );
+ TDateTime before = lastRDate.DateTime();
+ if ( lastRDate > untilTime )
+ {
+ rDateList.Remove( index-- );
+ }
+ else
+ {
+ index = KErrNotFound;
+ }
+ } while ( index != KErrNotFound );
+ }
+
+ // Need to check if the end date of the
+ // rrule needs adjusting if it exists.
+ TCalRRule rRule;
+ if ( iEntry.GetRRuleL( rRule ) )
+ {
+ count = rDateList.Count();
+ if ( count > 0 )
+ {
+ // There still exists some rdates, so only need to trim
+ // the rrule if it exists
+ TTime lastRDate = CalenDateUtils::BeginningOfDay( rDateList[ count - 1 ].TimeLocalL() );
+ const TTime& origUntilDate = Original().RepeatUntilDateTime();
+ TTime startDT = rRule.DtStart().TimeLocalL();
+
+ if ( lastRDate <= origUntilDate && startDT > lastRDate )
+ {
+ if ( startDT < untilTime)
+ {
+ if( origUntilDate != untilTime)
+ {
+ ApplyUntilDateToRRuleL( rRule, untilTime);
+ iEntry.SetRRuleL( rRule );
+ }
+ }
+ else
+ {
+ // The repeat start is after the until date
+ // so remove any repeat information.
+ iEntry.ClearRepeatingPropertiesL();
+
+ // If the entry date has been moved past the until
+ // date, need to swap the an rDate for the entry.
+ TTime startTime = iEntry.StartTimeL().TimeLocalL();
+
+ if ( startTime > untilTime )
+ {
+ // Find the duration of the entry
+ TTime endTime = iEntry.EndTimeL().TimeLocalL();
+ TTimeIntervalMinutes duration;
+ //startTime.MinutesFrom( endTime, duration );// for bug: CMCA-745CZ4
+ endTime.MinutesFrom( startTime, duration );
+
+ // Choose the first rDate as the new start time
+ TCalTime newStartTime = rDateList[ 0 ];
+ endTime = newStartTime.TimeLocalL() + duration;
+
+ // FIXME.
+ // If there is only one rDate left, the agenda model
+ // will crash if it is deleted.
+ if ( count != 0 )
+ {
+ rDateList.Remove( 0 );
+ }
+
+ TCalTime newEndTime;
+ if ( UseFloatingTimeL() )
+ {
+ newEndTime.SetTimeLocalFloatingL( endTime );
+ }
+ else
+ {
+ newEndTime.SetTimeLocalL( endTime );
+ }
+
+ iEntry.SetStartAndEndTimeL( newStartTime, newEndTime );
+ }
+ }
+ }
+ }
+ }
+
+ iEntry.SetRDatesL( rDateList );
+ }
+
+ CleanupStack::PopAndDestroy(); // rDateList
+ }
+ }
+ else
+ {
+ iEntry.ClearRepeatingPropertiesL();
+
+ // FIXME As the entry is supposedly not repeating
+ // any rDates should be removed. Unforunately this
+ // is not possible at the moment because removing the
+ // rdates will cause the agenda model to panic
+ //
+ // RArray<TCalTime> emptyList;
+ // CleanupClosePushL( emptyList );
+ // iEntry.SetRDatesL( emptyList );
+ // CleanupStack::PopAndDestroy(); // emptyList
+ }
+ }
+
+ if ( isNew || IsAlarmEditedL() && ( iEntry.StatusL() != CCalEntry::ETodoCompleted ) )
+ {
+ if ( Edited().IsAlarmActivated() )
+ {
+ CCalAlarm* alarm = iEntry.AlarmL();
+ if ( ! alarm )
+ {
+ alarm = CCalAlarm::NewL();
+ }
+ CleanupStack::PushL( alarm );
+
+ TTime startTime;
+ // ToDos don't have start time!
+ // If we have undated todo with alarm that was taken care earlier
+ if (iEntry.EntryTypeL()==CCalEntry::ETodo)
+ {
+ startTime = iEntry.EndTimeL().TimeLocalL();
+ }
+
+ // if this is not todo we use starttime normal way
+ else
+ {
+ startTime = iEntry.StartTimeL().TimeLocalL();
+ }
+ TCalRRule ignore;
+ TBool isRepeating = iEntry.GetRRuleL( ignore );
+
+ // If edit alarm of repeating entry, we have to nudge start
+ // time to instance date
+ if ( isRepeating && aRepeatTarget == CalCommon::EThisAndAll )
+ {
+ // nudge to instance date;
+ TTime instanceDate = iInstanceDateTime.TimeLocalL();
+ if ( IsStartDateTimeEdited() )
+ {
+ instanceDate = Edited().EventDateTime();
+ }
+
+ TDateTime insDt = instanceDate.DateTime();
+ TDateTime startDt = startTime.DateTime();
+ // Don't use individual setters (SetMonth, SetDay ...), because
+ // they break if month doesn't contain old date
+ // or date to be set.
+ startDt.Set( insDt.Year(), insDt.Month(), insDt.Day(),
+ startDt.Hour(), startDt.Minute(),
+ startDt.Second(), startDt.MicroSecond() );
+ startTime = TTime( startDt );
+ }
+
+ TTime alarmTime = Edited().AlarmDateTime();
+
+ TTimeIntervalMinutes offset;
+ startTime.MinutesFrom( alarmTime, offset );
+ alarm->SetTimeOffset( offset );
+
+ iEntry.SetAlarmL( alarm );
+ CleanupStack::PopAndDestroy( alarm );
+ }
+ else
+ {
+ iEntry.SetAlarmL( NULL );
+ }
+ }
+
+ if ( isNew || IsPriorityEdited() )
+ {
+ // map priority here
+ TUint priority = 0;
+ switch ( Edited().Priority() )
+ {
+ case CCalenEntryUtil::ETodoPriorityHigh:
+ priority = 1;
+ break;
+ case CCalenEntryUtil::ETodoPriorityNormal:
+ priority = 2;
+ break;
+ case CCalenEntryUtil::ETodoPriorityLow:
+ priority = 3;
+ break;
+ default:
+ ASSERT( EFalse );
+ break;
+ }
+ iEntry.SetPriorityL( priority );
+ }
+
+ if ( isNew )
+ {
+ CCalEntry::TReplicationStatus status = CCalEntry::EOpen;
+ switch ( Edited().SynchType() )
+ {
+ case CCalenEntryUtil::ESynchPrivate:
+ status = CCalEntry::EPrivate;
+ break;
+ case CCalenEntryUtil::ESynchPublic:
+ status = CCalEntry::EOpen;
+ break;
+ case CCalenEntryUtil::ESynchNoSync:
+ status = CCalEntry::ERestricted;
+ break;
+ default:
+ ASSERT( EFalse );
+ break;
+ }
+ iEntry.SetReplicationStatusL( status );
+ }
+
+ /**
+ * S60 settings for new entries
+ */
+ if ( IsCreatingNew() )
+ {
+ if ( Edited().EntryType() == CCalEntry::EAnniv )
+ {
+ TCalRRule rrule( TCalRRule::EYearly );
+ rrule.SetDtStart( iEntry.StartTimeL() );
+ rrule.SetInterval( 1 );
+ rrule.SetCount( 0 );
+ iEntry.SetRRuleL( rrule );
+ }
+ }
+
+ // check for attachments
+ if( isNew || IsAttachmentExists() )
+ {
+ // TODO: Uncomment this when enabling attachment support
+ AddAttachementsToEntryL();
+ }
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::ApplyUntilDateToRRuleL
+// Applies an new until date to a rrule
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::ApplyUntilDateToRRuleL( TCalRRule& aRRule, const TTime& aRepeatUntil ) const
+ {
+ TRACE_ENTRY_POINT;
+ // note repeat is set to forever.
+ if ( ! CalenDateUtils::IsValidDay( aRepeatUntil ) || IsForeverDate( aRepeatUntil ) )
+ {
+ // Set repeat to forever:
+ aRRule.SetCount( 0 );
+ }
+ else
+ {
+ // Change repeatuntil so that hours, minutes, ... are same as in start date
+ TDateTime dtUntil = aRepeatUntil.DateTime();
+ TDateTime dtStart= iEntry.StartTimeL().TimeLocalL().DateTime();
+
+ dtUntil.Set( dtUntil.Year(), dtUntil.Month(), dtUntil.Day(),
+ dtStart.Hour(), dtStart.Minute(), dtStart.Second(), dtStart.MicroSecond() );
+
+ TCalTime calRepeatUntil;
+ if ( UseFloatingTimeL() )
+ {
+ calRepeatUntil.SetTimeLocalFloatingL( TTime( dtUntil ) );
+ }
+ else
+ {
+ calRepeatUntil.SetTimeLocalL( TTime( dtUntil ) );
+ }
+ aRRule.SetUntil( calRepeatUntil );
+ }
+ TRACE_EXIT_POINT;
+ }
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::DurationGreaterThanRepeatIntervalError
+// Returns ETrue if the duration of instances of the meeting is greater than
+// the repeat period of the series, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::DurationGreaterThanRepeatIntervalError()
+ {
+ TRACE_ENTRY_POINT;
+ TBool isError = EFalse;
+ switch( Edited().RepeatType() )
+ {
+ case ERepeatDaily:
+ case ERepeatWorkdays:
+ {
+ TTime startDate = Edited().StartDateTime();
+ TTime endDate = Edited().EndDateTime();
+ // In case AllDay event end at "12:00am" 24/06/2009.
+ // editor should display EndDate as 23/06/2009.
+ if(Edited().IsAllDayEvent())
+ {
+ if( endDate > startDate )
+ {
+ endDate -= TTimeIntervalDays( 1 );
+ if( endDate < startDate )
+ {
+ endDate = startDate;
+ }
+ }
+ }
+ TTimeIntervalDays durDays = endDate.DaysFrom( startDate);
+ isError = durDays >= TTimeIntervalDays(1);
+ break;
+ }
+ case ERepeatWeekly:
+ {
+ TTimeIntervalDays durDays = Edited().EndDateTime().DaysFrom( Edited().StartDateTime() );
+ isError = durDays >= TTimeIntervalDays(7);
+ break;
+ }
+ case ERepeatBiWeekly:
+ {
+ TTimeIntervalDays durDays = Edited().EndDateTime().DaysFrom( Edited().StartDateTime() );
+ isError = durDays >= TTimeIntervalDays(14);
+ break;
+ }
+ case ERepeatMonthly:
+ {
+ TTimeIntervalMonths durMonths = Edited().EndDateTime().MonthsFrom( Edited().StartDateTime() );
+ isError = durMonths >= TTimeIntervalMonths(1);
+ break;
+ }
+ case ERepeatYearly:
+ {
+ TTimeIntervalYears durYears = Edited().EndDateTime().YearsFrom( Edited().StartDateTime() );
+ isError = durYears >= TTimeIntervalYears(1);
+ break;
+ }
+ case ERepeatOther:
+ {
+ isError = EFalse;
+ break;
+ }
+ default:
+ // Not repeating, no error
+ isError = EFalse;
+ break;
+ }
+ TRACE_EXIT_POINT;
+ return isError;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::CheckErrorsForThisAndAllL
+// Check for errors in the form. This function should only be called when the
+// user has decided they want to edit "This and all" from a prompt, or when the
+// entry is not repeating.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CCalenEditorDataHandler::TError CCalenEditorDataHandler::CheckErrorsForThisAndAllL()
+ {
+ TRACE_ENTRY_POINT;
+
+ // From UI spec:
+ // 5 checks is specified, only one not needed in this phase is 2.1
+
+ const TTime start = Edited().StartDateTime();
+ const TTime end = Edited().EndDateTime();
+
+ // 1) Check that entry doesn't end earlier than it starts
+ if ( end < start )
+ {
+ TRACE_EXIT_POINT;
+ return CCalenEditorDataHandler::EFormErrStopTimeEarlierThanStartTime;
+ }
+
+ // 2) Repeating entry checks:
+ if ( Edited().IsRepeating() )
+ {
+ // 2.1) Check that repeat until date is a) later than start date (for new notes)
+ // b) not before start date (for existing notes)
+ TTime repeatUntilDay = CalenDateUtils::BeginningOfDay(
+ Edited().RepeatUntilDateTime() );
+
+ TTime repeatStartDay;
+
+ // if new note or old note isnt repeating
+ // edited.repeatUntil date must be greater than edited.start date
+ // else
+ // if IsRepeatRuleEdited or IsStartDateTimeEdited
+ // //(either one above will make a new rule in which edited.startdate is the start date)
+ // edited.repeatUntil must be greater than edited.start date
+ // else
+ // edited.repeatUntil must be greater than start date on disk
+
+ TCalRRule rrule;
+ if( IsCreatingNew() ||
+ !Entry().GetRRuleL(rrule) ||
+ IsRepeatRuleEdited() ||
+ IsStartDateTimeEdited() )
+ {
+ // We don't have an rrule so we can't get the rrule start date,
+ // or user has edited a field that will cause new start date to be used in the new rule.
+ // Use the edited entry's start date.
+ repeatStartDay = CalenDateUtils::BeginningOfDay( start );
+ }
+ else
+ {
+ // original rrule is valid and new rule will not be created
+ repeatStartDay = CalenDateUtils::BeginningOfDay( rrule.DtStart().TimeLocalL() );
+ }
+
+ if ( repeatUntilDay <= repeatStartDay )
+ {
+ TRACE_EXIT_POINT;
+ return CCalenEditorDataHandler::EFormErrRepeatUntilEarlierThanNote;
+ }
+
+ if( DurationGreaterThanRepeatIntervalError() )
+ {
+ TRACE_EXIT_POINT;
+ return CCalenEditorDataHandler::EFormErrDurationGreaterThanRepeatInterval;
+ }
+ // 3) Alarm field checks:
+ TRACE_EXIT_POINT;
+ return CheckAlarmFieldsForErrorsL(ETrue); // user editing the series
+ }
+
+ // 3) Alarm field checks:
+ TRACE_EXIT_POINT;
+ return CheckAlarmFieldsForErrorsL(); // user editing the series
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::CheckErrorsForThisOnlyL
+// Check for errors in the form. This function should only be called when the
+// user has decided they want to edit "This only" from a prompt, or when the
+// entry is an exception.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CCalenEditorDataHandler::TError CCalenEditorDataHandler::CheckErrorsForThisOnlyL( CCalEntry& /*aParentEntry*/,
+ CCalInstanceView& /*aInstanceView*/ )
+ {
+ TRACE_ENTRY_POINT;
+
+ const TTime start = Edited().StartDateTime();
+ const TTime end = Edited().EndDateTime();
+
+ // Check that entry doesn't end earlier than it starts
+ if ( end < start )
+ {
+ TRACE_EXIT_POINT;
+ return CCalenEditorDataHandler::EFormErrStopTimeEarlierThanStartTime;
+ }
+
+ TError error = CheckForOutOfSequenceL();
+
+ if( error != EFormErrNone )
+ {
+ return error;
+ }
+
+ // Alarm field checks:
+ TRACE_EXIT_POINT;
+ return CheckAlarmFieldsForErrorsL(); // user creating/editing an exception
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::CheckForOutOfSequenceL
+// Checks to see if the instance is being moved out of sequence, relative to
+// the rest of the series.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CCalenEditorDataHandler::TError CCalenEditorDataHandler::CheckForOutOfSequenceL()
+ {
+ TRACE_ENTRY_POINT;
+ // Only perform the checks when we change the start or end time of the meeting.
+ if( !IsStartDateTimeEdited() && !IsEndDateTimeEdited() )
+ {
+ TRACE_EXIT_POINT;
+ return EFormErrNone;
+ }
+
+ TCalTime prevStart, prevEnd;
+
+ GetPreviousInstanceTimeL( prevStart, prevEnd );
+
+ if( prevStart.TimeLocalL() != Time::NullTTime() )
+ {
+ // Does the exception end on/after prevEnd?
+ if( Edited().StartDateTime() < prevEnd.TimeLocalL() )
+ {
+ // Does the exception start after prevStart?
+ if( Edited().StartDateTime() > prevStart.TimeLocalL() )
+ {
+ TRACE_EXIT_POINT;
+ return EFormErrOverlapsExistingInstance;
+ }
+ else
+ {
+ // Does the exception finish after prevStart?
+ if( Edited().EndDateTime() > prevStart.TimeLocalL() )
+ {
+ TRACE_EXIT_POINT;
+ return EFormErrOverlapsExistingInstance;
+ }
+ else
+ {
+ TRACE_EXIT_POINT;
+ return EFormErrOutOfSequence;
+ }
+ }
+ }
+
+ // Does the exception start on the same day as prevStart?
+ if( CalenDateUtils::OnSameDay( Edited().StartDateTime(), prevStart.TimeLocalL() ) )
+ {
+ TRACE_EXIT_POINT;
+ return EFormErrInstanceAlreadyExistsOnThisDay;
+ }
+ }
+
+ TCalTime nextStart, nextEnd;
+
+ GetNextInstanceTimeL( nextStart, nextEnd );
+
+ if( nextStart.TimeLocalL() != Time::NullTTime() )
+ {
+ // Does the exception finish on/before nextStart?
+ if( Edited().EndDateTime() > nextStart.TimeLocalL() )
+ {
+ // Does the exception finish before nextFinish?
+ if( Edited().EndDateTime() < nextEnd.TimeLocalL() )
+ {
+ TRACE_EXIT_POINT;
+ return EFormErrOverlapsExistingInstance;
+ }
+ else
+ {
+ // Does the exception start before nextFinish?
+ if( Edited().StartDateTime() < nextEnd.TimeLocalL() )
+ {
+ TRACE_EXIT_POINT;
+ return EFormErrOverlapsExistingInstance;
+ }
+ else
+ {
+ TRACE_EXIT_POINT;
+ return EFormErrOutOfSequence;
+ }
+ }
+ }
+
+ // Does the exception start on the same day as nextStart?
+ if( CalenDateUtils::OnSameDay( Edited().StartDateTime(), nextStart.TimeLocalL() ) )
+ {
+ TRACE_EXIT_POINT;
+ return EFormErrInstanceAlreadyExistsOnThisDay;
+ }
+ }
+
+ // Does the series have any rdates
+ RArray<TCalTime> rDateArray;
+ CleanupClosePushL( rDateArray );
+ Entry().GetRDatesL( rDateArray );
+ TInt rDateCount = rDateArray.Count();
+
+ if ( rDateCount > 0 )
+ {
+ // If the series has rdates, check that the exception
+ // does not overlap or start on the same day
+ const TTime& startDateTime = Edited().StartDateTime();
+ const TTime& endDateTime = Edited().EndDateTime();
+ TTimeIntervalMinutes duration;
+ startDateTime.MinutesFrom( endDateTime, duration );
+
+ for ( TInt index = 0; index < rDateCount; index++ )
+ {
+ const TTime& rDate = rDateArray[ index ].TimeLocalL();
+
+ if ( !CalenDateUtils::OnSameDay( Original().StartDateTime(), rDate ) )
+ {
+ // Does the exception start or end on the same day as a rdate.
+ if ( CalenDateUtils::OnSameDay( startDateTime, rDate ) )
+ {
+ CleanupStack::PopAndDestroy(); // rDateArray
+ TRACE_EXIT_POINT;
+ return EFormErrInstanceAlreadyExistsOnThisDay;
+ }
+
+ // Does the exception overlap an rdate?
+ TTime rDateEnd = rDate + duration;
+ if ( endDateTime > rDateEnd && startDateTime < rDate )
+ {
+ CleanupStack::PopAndDestroy(); // rDateArray
+ TRACE_EXIT_POINT;
+ return EFormErrOverlapsExistingInstance;
+ }
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // rDateArray
+ TRACE_EXIT_POINT;
+ return EFormErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::GetPreviousInstanceTimeL
+// Gets the start and end times of the previous instance. Sets both to a null
+// time if there is no instance before the current one
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::GetPreviousInstanceTimeL( TCalTime& aPreviousStartTime,
+ TCalTime& aPreviousEndTime )
+ {
+ TRACE_ENTRY_POINT;
+
+ aPreviousStartTime.SetTimeLocalL( Time::NullTTime() );
+ aPreviousEndTime.SetTimeLocalL( Time::NullTTime() );
+
+ RPointerArray<CCalEntry> entries;
+ CleanupResetAndDestroyPushL(entries);
+
+ EntryViewL().FetchL( Entry().UidL(), entries );
+
+ TCalTime currentInstanceDate = Entry().RecurrenceIdL();
+ if( currentInstanceDate.TimeUtcL() == Time::NullTTime() )
+ {
+ // We must be creating a new exception. Calculate the recurrence id.
+ TTimeIntervalMinutes timeOfDay = CalenDateUtils::TimeOfDay( entries[0]->StartTimeL().TimeLocalL() );
+ TTime beginningOfDay = CalenDateUtils::BeginningOfDay( InstanceDateTime().TimeLocalL() );
+ currentInstanceDate.SetTimeLocalL( beginningOfDay + timeOfDay );
+ }
+
+ TCalRRule rrule;
+ if( entries[0]->GetRRuleL(rrule) )
+ {
+ TCalenRepeatIndex repeatIndex = CalenNoteDataUtil::RepeatIndexL( *entries[0] );
+ TBool keepLooking = ETrue;
+ RArray<TCalTime> exdates;
+ CleanupClosePushL( exdates );
+ entries[0]->GetExceptionDatesL(exdates);
+
+ // Needed for case ERepeatOther
+ TCalRRule::TType type( rrule.Type() );
+ TInt repeatInterval( rrule.Interval() );
+ TCalTime start, end;
+ TTime previousInstanceTime = Time::NullTTime();
+
+ while( keepLooking )
+ {
+ // Subtract the repeat interval of the parent.
+ switch( repeatIndex )
+ {
+ case ERepeatDaily:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()-TTimeIntervalDays(1) );
+ break;
+ case ERepeatWeekly:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()-TTimeIntervalDays(7) );
+ break;
+ case ERepeatBiWeekly:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()-TTimeIntervalDays(14) );
+ break;
+ case ERepeatMonthly:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()-TTimeIntervalMonths(1) );
+ break;
+ case ERepeatYearly:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()-TTimeIntervalYears(1) );
+ break;
+ case ERepeatWorkdays:
+ currentInstanceDate.SetTimeLocalL(currentInstanceDate.TimeLocalL()-TTimeIntervalDays(7) );
+ case ERepeatOther:
+ /* This case includes repeating events like: 3 days every week, 3rd weekday of everymonth
+ that does not fall in any cases above but still have repeating rule*/
+
+ // Check if the current entry being edited is child entry
+ // If yes, then put back the child entry time to currentInstanceDate
+ if(Entry().RecurrenceIdL().TimeUtcL() != Time::NullTTime() )
+ {
+ TTimeIntervalMinutes timeOfDay = CalenDateUtils::TimeOfDay( Entry().StartTimeL().TimeLocalL() );
+ TTime beginningOfDay = CalenDateUtils::BeginningOfDay( InstanceDateTime().TimeLocalL() );
+ currentInstanceDate.SetTimeLocalL( beginningOfDay + timeOfDay );
+ }
+
+ switch( type )
+ {
+ case TCalRRule::EDaily:
+ start.SetTimeLocalL( currentInstanceDate.TimeLocalL()-TTimeIntervalDays(1 * repeatInterval));
+ break;
+ case TCalRRule::EWeekly:
+ start.SetTimeLocalL( currentInstanceDate.TimeLocalL()-TTimeIntervalDays(7 * repeatInterval));
+ break;
+ case TCalRRule::EMonthly:
+ // Add 7 days of buffer to cover the cases were gap b/w two instances of the event
+ // can go beuong 30 days. Ex: Every third wednesday of every month
+ start.SetTimeLocalL( currentInstanceDate.TimeLocalL()-TTimeIntervalMonths(repeatInterval)-TTimeIntervalDays(7 * repeatInterval));
+ break;
+ case TCalRRule::EYearly:
+ // Add 7 days of buffer to cover the cases were gap b/w two instances of the event
+ // can go beuong 365 days. Ex: Every third wednesday of September of every year
+ start.SetTimeLocalL( currentInstanceDate.TimeLocalL()-TTimeIntervalYears(repeatInterval)-TTimeIntervalDays(7 * repeatInterval));
+ break;
+ }
+
+ end.SetTimeLocalL(CalenDateUtils::BeginningOfDay(currentInstanceDate.TimeLocalL()));
+ previousInstanceTime = GetPreviousInstanceForRepeatOtherL(*entries[0], CalCommon::TCalTimeRange( start, end));
+ currentInstanceDate.SetTimeLocalL( previousInstanceTime);
+ break;
+ default:
+ case ERepeatNotRepeated:
+ keepLooking = EFalse;
+ break;
+ }
+
+ // Is currentInstanceDate before parent dt start?
+ if( currentInstanceDate.TimeLocalL() < entries[0]->StartTimeL().TimeLocalL() )
+ {
+ // There are no instances before the exception
+ keepLooking = EFalse;
+ }
+ else
+ {
+ // Is there an exdate on currentInstanceDate?
+ TBool isExdateOnDay = EFalse;
+ for(TInt i=0; i<exdates.Count(); ++i)
+ {
+ if( exdates[i].TimeLocalL() == currentInstanceDate.TimeLocalL() )
+ {
+ isExdateOnDay = ETrue;
+ // There is an exdate - is there a child associated with the exdate?
+ for(TInt j=1; j<entries.Count(); ++j)
+ {
+ if( entries[j]->RecurrenceIdL().TimeLocalL() == currentInstanceDate.TimeLocalL() )
+ {
+ // This child is the previous instance.
+ aPreviousStartTime = entries[j]->StartTimeL();
+ aPreviousEndTime = entries[j]->EndTimeL();
+ keepLooking = EFalse;
+ }
+ }
+ break;
+ }
+ }
+
+ if( !isExdateOnDay )
+ {
+ // The instance exists and hasn't been deleted or made into an exception.
+ // Use information from the parent to set the start/end times.
+ aPreviousStartTime = currentInstanceDate;
+
+ TTimeIntervalMinutes duration;
+ TTime start = entries[0]->StartTimeL().TimeLocalL();
+ TTime end = entries[0]->EndTimeL().TimeLocalL();
+ end.MinutesFrom( start, duration );
+ aPreviousEndTime.SetTimeLocalL( currentInstanceDate.TimeLocalL() + duration );
+ keepLooking = EFalse;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( &exdates );
+ }
+
+ CleanupStack::PopAndDestroy(&entries);
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::GetNextInstanceTimeL
+// Gets the start and end times of the next instance. Sets both to a null
+// time if there is no instance after the current one.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::GetNextInstanceTimeL( TCalTime& aNextStartTime,
+ TCalTime& aNextEndTime )
+ {
+ TRACE_ENTRY_POINT;
+
+ aNextStartTime.SetTimeLocalL( Time::NullTTime() );
+ aNextEndTime.SetTimeLocalL( Time::NullTTime() );
+
+ RPointerArray<CCalEntry> entries;
+ CleanupResetAndDestroyPushL(entries);
+
+ EntryViewL().FetchL( Entry().UidL(), entries );
+
+ TCalTime currentInstanceDate = Entry().RecurrenceIdL();
+ if( currentInstanceDate.TimeUtcL() == Time::NullTTime() )
+ {
+ // We must be creating a new exception. Calculate the recurrence id.
+ TTimeIntervalMinutes timeOfDay = CalenDateUtils::TimeOfDay( entries[0]->StartTimeL().TimeLocalL() );
+ TTime beginningOfDay = CalenDateUtils::BeginningOfDay( InstanceDateTime().TimeLocalL() );
+ currentInstanceDate.SetTimeLocalL( beginningOfDay + timeOfDay );
+ }
+
+ TCalRRule rrule;
+ if( entries[0]->GetRRuleL(rrule) )
+ {
+ TCalenRepeatIndex repeatIndex = CalenNoteDataUtil::RepeatIndexL( *entries[0] );
+ TBool keepLooking = ETrue;
+ RArray<TCalTime> exdates;
+ CleanupClosePushL( exdates );
+ entries[0]->GetExceptionDatesL(exdates);
+
+ // Needed for case ERepeatOther
+ TCalRRule::TType type( rrule.Type() );
+ TInt repeatInterval( rrule.Interval() );
+ TCalTime start, end;
+ TTime nextInstanceTime = Time::NullTTime();
+
+ while( keepLooking )
+ {
+ // Subtract the repeat interval of the parent.
+ switch( repeatIndex )
+ {
+ case ERepeatDaily:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()+TTimeIntervalDays(1) );
+ break;
+ case ERepeatWeekly:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()+TTimeIntervalDays(7) );
+ break;
+ case ERepeatBiWeekly:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()+TTimeIntervalDays(14) );
+ break;
+ case ERepeatMonthly:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()+TTimeIntervalMonths(1) );
+ break;
+ case ERepeatYearly:
+ currentInstanceDate.SetTimeLocalL( currentInstanceDate.TimeLocalL()+TTimeIntervalYears(1) );
+ break;
+ case ERepeatWorkdays:
+ currentInstanceDate.SetTimeLocalL(currentInstanceDate.TimeLocalL()+TTimeIntervalDays(7) );
+ break;
+ case ERepeatOther:
+ {
+ /* This case includes repeating events like: 3 days every week, 3rd weekday of everymonth
+ that does not fall in any cases above but still have repeating rule*/
+
+ // Check if the current entry being edited is child entry
+ // If yes, then put back the child entry time to currentInstanceDate
+ if(Entry().RecurrenceIdL().TimeUtcL() != Time::NullTTime())
+ {
+ TTimeIntervalMinutes timeOfDay = CalenDateUtils::TimeOfDay( Entry().StartTimeL().TimeLocalL() );
+ TTime beginningOfDay = CalenDateUtils::BeginningOfDay( InstanceDateTime().TimeLocalL() );
+ currentInstanceDate.SetTimeLocalL( beginningOfDay + timeOfDay );
+ }
+ switch( type )
+ {
+ case TCalRRule::EDaily:
+ end.SetTimeLocalL( currentInstanceDate.TimeLocalL()+TTimeIntervalDays(1 * repeatInterval));
+ break;
+ case TCalRRule::EWeekly:
+ end.SetTimeLocalL( currentInstanceDate.TimeLocalL()+TTimeIntervalDays(7 * repeatInterval));
+ break;
+ case TCalRRule::EMonthly:
+ // Add 7 days of buffer to cover the cases were gap b/w two instances of the event
+ // can go beuong 30 days. Ex: Every third wednesday of every month
+ end.SetTimeLocalL( currentInstanceDate.TimeLocalL()+TTimeIntervalMonths(repeatInterval)+TTimeIntervalDays(7 * repeatInterval));
+ break;
+ case TCalRRule::EYearly:
+ // Add 7 days of buffer to cover the cases were gap b/w two instances of the event
+ // can go beuong 365 days. Ex: Every third wednesday of September of every year
+ end.SetTimeLocalL( currentInstanceDate.TimeLocalL()+TTimeIntervalYears(repeatInterval)+TTimeIntervalDays(7 * repeatInterval));
+ break;
+ }
+
+ start.SetTimeLocalL(CalenDateUtils::BeginningOfDay(currentInstanceDate.TimeLocalL()+TTimeIntervalDays(1)));
+
+ nextInstanceTime = GetNextInstanceForRepeatOtherL(*entries[0], CalCommon::TCalTimeRange( start, end));
+ currentInstanceDate.SetTimeLocalL( nextInstanceTime);
+ break;
+ }
+ case ERepeatNotRepeated:
+ keepLooking = EFalse;
+ break;
+ default:
+ break;
+ }
+
+ // Is currentInstanceDate after parent dt end?
+ if( currentInstanceDate.TimeLocalL() > rrule.Until().TimeLocalL() )
+ {
+ // There are no instances before the exception
+ keepLooking = EFalse;
+ }
+ else
+ {
+ // Is there an exdate on currentInstanceDate?
+ TBool isExdateOnDay = EFalse;
+ for(TInt i=0; i<exdates.Count(); ++i)
+ {
+ if( exdates[i].TimeLocalL() == currentInstanceDate.TimeLocalL() )
+ {
+ isExdateOnDay = ETrue;
+ // There is an exdate - is there a child associated with the exdate?
+ for(TInt j=1; j<entries.Count(); ++j)
+ {
+ if( entries[j]->RecurrenceIdL().TimeLocalL() == currentInstanceDate.TimeLocalL() )
+ {
+ // This child is the previous instance.
+ aNextStartTime = entries[j]->StartTimeL();
+ aNextEndTime = entries[j]->EndTimeL();
+ keepLooking = EFalse;
+ }
+ }
+ break;
+ }
+ }
+
+ if( !isExdateOnDay )
+ {
+ // The instance exists and hasn't been deleted or made into an exception.
+ // Use information from the parent to set the start/end times.
+ aNextStartTime = currentInstanceDate;
+
+ TTimeIntervalMinutes duration;
+ TTime start = entries[0]->StartTimeL().TimeLocalL();
+ TTime end = entries[0]->EndTimeL().TimeLocalL();
+ end.MinutesFrom( start, duration );
+ aNextEndTime.SetTimeLocalL( currentInstanceDate.TimeLocalL() + duration );
+ keepLooking = EFalse;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( &exdates );
+ }
+
+ CleanupStack::PopAndDestroy(&entries);
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::CheckAlarmFieldsForErrorsL
+// Check the alarm fields for errors. Returns the error if found, or
+// EFormErrNone if no error found.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CCalenEditorDataHandler::TError CCalenEditorDataHandler::CheckAlarmFieldsForErrorsL(TBool aSeries)
+ {
+ TRACE_ENTRY_POINT;
+
+ TError error = EFormErrNone;
+ // If alarm not active, no check
+ if ( Edited().IsAlarmActivated() )
+ {
+ TTime alarm = Edited().AlarmDateTime();
+ TTime startTime = Edited().StartDateTime();
+ TTime now(Time::NullTTime());
+ now.HomeTime();
+
+ if(IsAlarmInAcceptablePeriod(error, alarm, startTime))
+ {
+ // ask form (not iEntry) if it is repeating
+ // if we launched an old exception, then form has no repeat field
+ // if creating a new exception, then form has repeat field
+ TBool EventIsInFuture = (IsTimedEntry() && (startTime > now)) ||
+ (!IsTimedEntry() && (startTime.DaysFrom(now) >= TTimeIntervalDays(0)));
+ if( !aSeries && (alarm < now) && ( iEdited->EntryType()!=CCalEntry::EAnniv ) )
+ {
+ // dont let non-repeating future entries have alarms in past
+ error = EFormErrAlarmTimePast;
+ }
+ /* otherwise, save alarm to past:
+ * new/old non-repeating & in past
+ * repeating new/old repeating in past/future
+ */
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsAlarmInAcceptablePeriod
+// Check alarm time validity
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsAlarmInAcceptablePeriod(TError& aError,
+const TTime& aAlarmTime, const TTime& aStartTime) const
+ {
+ TRACE_ENTRY_POINT;
+
+ TTime upperLimit = IsTimedEntry() ?
+ aStartTime :
+ CalenDateUtils::BeginningOfDay(aStartTime) + TTimeIntervalDays(1);
+ TTime lowerLimit = aStartTime - TTimeIntervalDays(31);
+ TBool acceptable = ETrue;
+ if(aAlarmTime < lowerLimit)
+ {
+ acceptable = EFalse;
+ aError = EFormErrAlarmDateTooManyDaysBeforeNote;
+ }
+ else if(aAlarmTime > upperLimit)
+ {
+ acceptable = EFalse;
+ aError = EFormErrAlarmTimeLaterThanNote;
+ }
+
+ TRACE_EXIT_POINT;
+ return acceptable;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::ForceValidValuesL
+// Force the form to use valid values. This function gets called when the user
+// forces the application to exit, for example by pressing the off button.
+// We attempt to save as much data as possible from the form.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::ForceValidValuesL( CalCommon::TRecurrenceRange aRepeatTarget )
+ {
+ TRACE_ENTRY_POINT;
+
+ // Checks and valid values are
+ // from S60 Calendar UI spec, chapter 4.6.4.1 Exiting Note Editor:
+
+ // We modify values as we go, thus we can't pre-read fields.
+ // E.g. when start time is needed in check, it should be always read
+ // from model, because previous check might have modified it.
+
+ // 2) if ends earlier than starts
+ if ( Edited().EndDateTime() < Edited().StartDateTime() )
+ {
+ // a) (for new entry) set end time equal to start time
+ if ( IsCreatingNew() )
+ {
+ Edited().SetEndDateTimeL( Edited().StartDateTime() );
+ }
+ // b) (for existing entries) replace with original end time
+ else
+ {
+ Edited().SetEndDateTimeL( Original().EndDateTime() );
+ // if still wrong, replace start time also
+ Edited().SetStartDateTimeL( Original().StartDateTime() );
+ }
+ } // END end < start check
+
+ // 1) Alarm validation
+ if ( Edited().IsAlarmActivated() )
+ {
+ TTime now;
+ now.HomeTime();
+
+ // Note: all three checks are done for each alarm.
+ // Alarm time is read always again, because modifications are done after each check
+
+ // 1.1) a) if alarm more than 31 days before start, alarm is set 31 days before start
+ // b) (for todos) - "" - before due date
+ TTime maxAlarmBeforeStart = Edited().StartDateTime() - TTimeIntervalDays( 31 );
+ if ( Edited().AlarmDateTime() < maxAlarmBeforeStart )
+ {
+ Edited().SetAlarmDateTimeL( maxAlarmBeforeStart );
+ }
+
+ // 1.2) a) (meetings) if alarm later than start, set it to default alarm time
+ // b) (for todos & annivs) - "" - later than due date
+ TTime atLatest = Edited().StartDateTime();
+ if(!IsTimedEntry())
+ {
+ atLatest += TTimeIntervalDays(1);
+ atLatest -= TTimeIntervalSeconds(1);
+ // at Latest for ToDo/Anniv would be DD @ 23:59:59
+ }
+ if( Edited().AlarmDateTime() > atLatest )
+ {
+ SetDefaultAlarmDateTimeL();
+ }
+
+ // 1.3) if alarm is set to passed time,
+ if ( Edited().AlarmDateTime() < now )
+ {
+ // a) it is set off for
+ // - new/old NON-REPEATING entries
+ if (!Edited().IsRepeating() && Edited().EntryType() != CCalEntry::EAnniv )
+ {
+ Edited().SetAlarmOffL();
+ }
+ // b) (for existing entries) it is saved, unless it has failed 1.1 or 1.2
+ else
+ {
+ // keep, if it is repeating entry, since repeating entries
+ // can have alarms in past
+ }
+ }
+ } // END alarm checks
+
+ // 3) Repeat rule checks
+ if ( Edited().IsRepeating() )
+ {
+ // if repeating note's repeat until date
+ // a) (for new entries) isn't one day later than start date
+ // b) (for existing entries) is before start date
+ // set it to one year later from start date
+ TTime repeatUntilDay = CalenDateUtils::BeginningOfDay(
+ Edited().RepeatUntilDateTime() );
+ TTime startDay = CalenDateUtils::BeginningOfDay( Edited().StartDateTime() );
+ if ( ( IsCreatingNew() && repeatUntilDay <= startDay) ||
+ (! IsCreatingNew() && repeatUntilDay < startDay) )
+ {
+ Edited().SetRepeatUntilDateTimeL( startDay + TTimeIntervalYears(1) );
+ }
+ }
+
+ // 4) if due date of todo is passed or invalid, save it with entered date
+ // no operation (this is just clarification in UI spec
+
+
+ // 5) Check for out of sequence for exceptions
+ // 6) Check for duration > rpt interval for series
+
+ if( aRepeatTarget == CalCommon::EThisOnly )
+ {
+ TError error = CheckForOutOfSequenceL();
+
+ if( error != EFormErrNone )
+ {
+ // Revert start/end times
+ Edited().SetStartDateTimeL( Original().StartDateTime() );
+ Edited().SetEndDateTimeL( Original().EndDateTime() );
+ }
+ }
+ else if( aRepeatTarget == CalCommon::EThisAndAll )
+ {
+ if( DurationGreaterThanRepeatIntervalError() )
+ {
+ // Revert start/end times
+ Edited().SetStartDateTimeL( Original().StartDateTime() );
+ Edited().SetEndDateTimeL( Original().EndDateTime() );
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsOldEntry
+// Returns ETrue if the entry was already created previously so that
+// we are now editing it, returns EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsOldEntry()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return !IsCreatingNew();
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::AreTextFieldsEmptyL
+// Returns ETrue if summary && location && description text fields are all empty
+// Returns EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::AreTextFieldsEmptyL()
+ {
+ TRACE_ENTRY_POINT;
+
+ // We have to consider texts empty, if only summary is empty, in case
+ // location is not supported, because location can still exists in database.
+ TBool summaryAndDescriptionEmpty = CalenAgendaUtils::IsEmptyText( iEdited->Summary() ) &&
+ CalenAgendaUtils::IsEmptyText( iEdited->Description() );
+
+ if(LocationEnabledInUiL())
+ {
+ TRACE_EXIT_POINT;
+ return summaryAndDescriptionEmpty && CalenAgendaUtils::IsEmptyText( iEdited->Location() );
+ }
+
+ TRACE_EXIT_POINT;
+
+ return summaryAndDescriptionEmpty; // and location is empty implicitly
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::AreTextFieldsClearedL
+// Returns ETrue if the user cleared the text in the location and summary fields.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::AreTextFieldsClearedL()
+ {
+ TRACE_ENTRY_POINT;
+
+ if ( CalenAgendaUtils::IsEmptyText( iEdited->Summary() ) &&
+ CalenAgendaUtils::IsEmptyText( iEdited->Description() ) )
+ {
+ if ( LocationEnabledInUiL() )
+ {
+ if ( CalenAgendaUtils::IsEmptyText( iEdited->Location() ) )
+ {
+ if ( IsSummaryEmptied() || IsDescriptionEmptied() || IsLocationEmptied() )
+ {
+ TRACE_EXIT_POINT;
+ return ETrue;
+ }
+ }
+ }
+
+ else if ( IsSummaryEmptied() || IsDescriptionEmptied() )
+ {
+ TRACE_EXIT_POINT;
+ return ETrue;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsDescriptionEmptied
+// Returns ETrue, the description was not empty in original && is empty
+// in the edited note
+// Returns EFalse, otherwise
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+TBool CCalenEditorDataHandler::IsDescriptionEmptied()
+ {
+ TRACE_ENTRY_POINT;
+
+ if( !CalenAgendaUtils::IsEmptyText( iOriginal->Description() ) &&
+ CalenAgendaUtils::IsEmptyText( iEdited->Description() ) )
+ {
+ TRACE_EXIT_POINT;
+ return ETrue;
+ }
+
+ TRACE_EXIT_POINT;
+
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsSummaryEmptied
+// Returns ETrue, the summary was not empty in original && is empty
+// in the edited note
+// Returns EFalse, otherwise
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+TBool CCalenEditorDataHandler::IsSummaryEmptied()
+ {
+ TRACE_ENTRY_POINT;
+
+ if( !CalenAgendaUtils::IsEmptyText( iOriginal->Summary() ) &&
+ CalenAgendaUtils::IsEmptyText( iEdited->Summary() ) )
+ {
+ TRACE_EXIT_POINT;
+ return ETrue;
+ }
+
+ TRACE_EXIT_POINT;
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsLocationEmptied
+// Returns ETrue, the summary was not empty in original && is empty
+// in the edited note
+// Returns EFalse, otherwise
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+TBool CCalenEditorDataHandler::IsLocationEmptied()
+ {
+ TRACE_ENTRY_POINT;
+
+ if( !CalenAgendaUtils::IsEmptyText( iOriginal->Location() ) &&
+ CalenAgendaUtils::IsEmptyText( iEdited->Location() ) )
+ {
+ TRACE_EXIT_POINT;
+ return ETrue;
+ }
+
+ TRACE_EXIT_POINT;
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsEntryTypeEdited
+// Returns ETrue if the 'Entry Type' is edited, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsEntryTypeEdited()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return iOriginal->EntryType() != iEdited->EntryType();
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsStartDateTimeEdited
+// Returns ETrue if the start date/time has been edited, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsStartDateTimeEdited()
+ {
+ TRACE_ENTRY_POINT;
+
+ TBool isEdited = EFalse;
+
+ TTime orgTTime = iOriginal->StartDateTime();
+ TTime editedTTime = iEdited->StartDateTime();
+
+ // Get TDateTime of Original & Edited entries.
+ TDateTime orgDT = orgTTime.DateTime();
+ TDateTime editedDT = editedTTime.DateTime();
+
+ if( !IsTimedEntry() && IsCreatingNew() )
+ {
+ // For non-timed event,on while creating new entry.
+ // check for only Date field change only.
+ if( orgDT.Day() != editedDT.Day() ||
+ orgDT.Month() != editedDT.Month() ||
+ orgDT.Year() != editedDT.Year() )
+ {
+ isEdited = ETrue;
+ }
+ }
+ else
+ {
+
+ // For timed entry, check for Entry Date/Time Changes
+ if( orgTTime != editedTTime )
+ {
+ isEdited = ETrue;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return isEdited;
+
+ //return iOriginal->StartDateTime() != iEdited->StartDateTime();
+
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsEndDateTimeEdited
+// Returns ETrue if the end date/time has been edited, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsEndDateTimeEdited()
+ {
+ TRACE_ENTRY_POINT;
+ TBool isEdited = EFalse;
+
+ TTime orgTTime = iOriginal->EndDateTime();
+ TTime editedTTime = iEdited->EndDateTime();
+
+ // Get TDateTime of Original & Edited entries.
+ TDateTime orgDT = orgTTime.DateTime();
+ TDateTime editedDT = editedTTime.DateTime();
+
+ if( !IsTimedEntry() && IsCreatingNew() )
+ {
+
+ // For non-timed event, check for only Date field change.
+ // No need to check for Entry time change.
+ if( orgDT.Day() != editedDT.Day() ||
+ orgDT.Month() != editedDT.Month() ||
+ orgDT.Year() != editedDT.Year() )
+ {
+ isEdited = ETrue;
+ }
+ }
+ else
+ {
+ // For timed entry, check for Entry Date/Time Changes
+ if( orgTTime != editedTTime )
+ {
+ isEdited = ETrue;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return isEdited;
+
+ //return iOriginal->EndDateTime() != iEdited->EndDateTime();
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsDescriptionEdited
+// Returns ETrue if the description has been modified, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsDescriptionEdited()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return iOriginal->Description() != iEdited->Description();
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsPriorityEdited
+// Returns ETrue if the priotity has been modified, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsPriorityEdited()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return iOriginal->Priority() != iEdited->Priority();
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsCalendarEditedL
+// Returns ETrue if the calendar filed has been edited, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsCalendarEditedL()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return iCalendarFieldEdited;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsSummaryEdited
+// Returns ETrue if the summary has been edited, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsSummaryEdited()
+ {
+ TRACE_ENTRY_POINT;
+
+ // For summary and location, we compare only that part of text
+ // that fits to editor. If it's equal, then we don't go and unnecessarily
+ // truncate existing data.
+ TRACE_EXIT_POINT;
+ return ( iOriginal->Summary().Left( iMaxTextEditorLength )
+ != iEdited->Summary().Left( iMaxTextEditorLength ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsLocationEdited
+// Returns ETrue if the location has been edited, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsLocationEdited()
+ {
+ TRACE_ENTRY_POINT;
+
+ // For summary and location, we compare only that part of text
+ // that fits to editor. If it's equal, then we don't go and unnecessarily
+ // truncate existing data.
+ TRACE_EXIT_POINT;
+ return ( iOriginal->Location().Left( iMaxTextEditorLength )
+ != iEdited->Location().Left( iMaxTextEditorLength ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsAlarmEditedL
+// Returns ETrue if the alarm has been edited, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsAlarmEditedL()
+ {
+ TRACE_ENTRY_POINT;
+
+ if ( iOriginal->IsAlarmActivated() && iEdited->IsAlarmActivated() )
+ {
+ // The alarm must be flagged as changed if the interval between the entry start
+ // and the alarm is different. (We can't just compare alarm times directly because
+ // the start date of the entry may have changed.)
+ TTimeIntervalMinutes origOffset, editedOffset;
+
+ User::LeaveIfError( iOriginal->AlarmDateTime().MinutesFrom( iOriginal->StartDateTime(), origOffset ) );
+ User::LeaveIfError( iEdited->AlarmDateTime().MinutesFrom( iEdited->StartDateTime(), editedOffset ) );
+
+ TBool alarmTimeChanged = origOffset != editedOffset;
+
+ TRACE_EXIT_POINT;
+ return alarmTimeChanged;
+ }
+ else
+ {
+ TBool statusChanged = iOriginal->IsAlarmActivated() != iEdited->IsAlarmActivated();
+
+ TRACE_EXIT_POINT;
+ return statusChanged;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsRepeatRuleEdited
+// Returns ETrue if the repeat rule has been edited, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsRepeatRuleEdited()
+ {
+ TRACE_ENTRY_POINT;
+
+ if ( iOriginal->IsRepeating() && iEdited->IsRepeating() )
+ {
+ TBool repeatTypeChanged = iOriginal->RepeatType() != iEdited->RepeatType();
+ TBool untilDateChanged = iOriginal->RepeatUntilDateTime() != iEdited->RepeatUntilDateTime();
+
+ TRACE_EXIT_POINT;
+ return repeatTypeChanged || untilDateChanged;
+ }
+ else
+ {
+ TBool statusChanged = iOriginal->IsRepeating() != iEdited->IsRepeating();
+
+ TRACE_EXIT_POINT;
+ return statusChanged;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::LocationEnabledInUiL
+// Returns ETrue if the location is a valid field for this type of entry
+// (i.e. meetings & reminders only), EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::LocationEnabledInUiL()
+ {
+ TRACE_ENTRY_POINT;
+
+ // Location is enabled for timed entries (i.e. an appointment or a
+ // reminder)
+ TRACE_EXIT_POINT;
+ return IsTimedEntry();
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsTimedEntry
+// Returns ETrue if this is a timed entry, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsTimedEntry() const
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return IsTimed( iEdited->EntryType() );
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsCreatingNew
+// Returns ETrue if the user is creating a new entry, EFalse if the user is
+// editing an existing entry.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsCreatingNew() const
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return iIsCreatingNew;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsStartDateChanged
+// Returns ETrue if the start date of the entry has been changed,
+// EFalse otherwise. Note that this function only checks the date,
+// and not the time of day, of the entry.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsStartDateChanged()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return ! CalenDateUtils::OnSameDay( iOriginal->StartDateTime(),
+ iEdited->StartDateTime() );
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsAttachmentExists
+// Returns ETrue calendar entry is having attachments
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsAttachmentExists()
+ {
+ TRACE_ENTRY_POINT;
+ TBool attachmentExits(EFalse);
+
+ // TODO: Uncomment this when enabling attachment support
+
+ if( (iOriginal->AttachmentCount() != iEdited->AttachmentCount())
+ || iServices.GetAttachmentData()->NumberOfItems() )
+ {
+ attachmentExits = ETrue;
+ }
+
+ TRACE_EXIT_POINT;
+ return attachmentExits;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsEventTypeEdited
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsEventTypeEdited()
+ {
+ TRACE_ENTRY_POINT;
+ TBool fieldModified = EFalse;
+
+ // Check EventType field is edited for already saved Entry
+ // For Newly created entry, ignore the EventTypeChange
+ if( (iOriginal->EntryType() != iEdited->EntryType()) && !IsCreatingNew() )
+ {
+ fieldModified = ETrue;
+ }
+
+ TRACE_EXIT_POINT;
+ return fieldModified;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::AllDayFieldEdited
+// Returns ETrue if `All day event' line has been modified.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::AllDayFieldEdited()
+ {
+ TRACE_ENTRY_POINT;
+ TBool fieldModified = EFalse;
+
+ if( iOriginal->IsAllDayEvent() != iEdited->IsAllDayEvent() )
+ {
+ fieldModified = ETrue;
+ }
+
+ TRACE_EXIT_POINT;
+ return fieldModified;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::SetDefaultAlarmDateTimeL
+// Sets the alarm to the default value. This function is called after the user
+// forces an exit, e.g. when pressing the power off button.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::SetDefaultAlarmDateTimeL()
+ {
+ TRACE_ENTRY_POINT;
+
+ /**
+ * Default alarm time is UI spec logic.
+ * It is important that this is here, because there shouldn't be UI spec logic in CCalenEntryUtil,
+ * only in CCalenEditorDataHandler.
+ *
+ * It is still a bit odd, that other set methods are in CCalenEntryUtil but not here.
+ * Maybe I add wrapper set methods for edited data also in *Handler.
+ * e.g. void SetAlarmOffL() { Edited().SetAlarmOffL(); }
+ *
+ */
+ TTime defaultAlarm;
+
+ if ( IsTimedEntry() )
+ {
+ TTimeIntervalMinutes defaultOffsetM( 15 ); // FIXME: should be read from central repository
+ defaultAlarm = Edited().StartDateTime() - defaultOffsetM;
+ }
+ else
+ {
+ TTimeIntervalHours defaultOffsetH( -8 );
+ defaultAlarm = CalenDateUtils::BeginningOfDay( Edited().EventDateTime() ) - defaultOffsetH;
+ }
+
+ Edited().SetAlarmOnL( defaultAlarm );
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::CalculateRepeatRuleL
+// Calculates the repeat rule for a given entry.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::CalculateRepeatRuleL(
+ const TTime& aStartDateTime,
+ TCalenRepeatIndex aNewRepeatType,
+ const TTime& aRepeatUntil,
+ TCalRRule& aRRule)
+ {
+ TRACE_ENTRY_POINT;
+
+ // FIXME: This is copy-pasted from old implementation.
+ // This should be rewritten with care.
+ //If it ain't broke...?
+ TTime startDateTime = aStartDateTime;
+ TTime repeatUntil = aRepeatUntil;
+
+ TCalRRule origRRule;
+ TBool hasOrigRRule = iEntry.GetRRuleL( origRRule );
+
+ TBool isStartDateSame = CalenDateUtils::OnSameDay(
+ Original().StartDateTime(), Edited().StartDateTime() );
+
+ //
+ // If repeat type is changed, repeat start date
+ // is replaced to the date of "Start date" field.
+ //
+ if ( hasOrigRRule &&
+ isStartDateSame &&
+ aNewRepeatType == Original().RepeatType() )
+ {
+ aRRule = origRRule; // keep the original setting...
+ // until date changed?
+ }
+ else if (aNewRepeatType == ERepeatOther)
+ {
+ // prevRptDef is ALWAYS non-NULL in this block,
+ // because previous note's repeat ALWAYS exists.
+ aRRule = origRRule;
+ TCalTime repeatStart;
+ if ( UseFloatingTimeL() )
+ {
+ repeatStart.SetTimeLocalFloatingL( startDateTime );
+ }
+ else
+ {
+ repeatStart.SetTimeLocalL( startDateTime );
+ }
+ aRRule.SetDtStart( repeatStart );
+ }
+ else
+ {
+ TCalTime repeatSt;
+ if ( UseFloatingTimeL() )
+ {
+ repeatSt.SetTimeLocalFloatingL( startDateTime );
+ }
+ else
+ {
+ repeatSt.SetTimeLocalL( startDateTime );
+ }
+ aRRule.SetDtStart( repeatSt );
+ aRRule.SetInterval( 1 );
+
+ TInt interval(1);
+
+ switch ( aNewRepeatType )
+ {
+ case (ERepeatDaily): // Daily
+ {
+ aRRule.SetType( TCalRRule::EDaily );
+ break;
+ }
+ case (ERepeatWeekly): // Weekly
+ {
+ if (hasOrigRRule && origRRule.Type() == TCalRRule::EDaily &&
+ origRRule.Interval() == 7)
+ {
+ // If old note's repeat is every 7 days,
+ // set repeat to every 7 days to Agenda, NOT every week.
+ //
+ aRRule.SetType( TCalRRule::EDaily );
+ interval = 7;
+ }
+ else
+ {
+ aRRule.SetType( TCalRRule::EWeekly );
+
+ RArray<TDay> dayArray;
+ CleanupClosePushL( dayArray );
+ dayArray.Append( aRRule.DtStart().TimeLocalL().DayNoInWeek() );
+ aRRule.SetByDay( dayArray );
+ CleanupStack::PopAndDestroy( &dayArray );
+ }
+ break;
+ }
+ case (ERepeatBiWeekly): // Bi-weekly
+ {
+ if ( hasOrigRRule && origRRule.Type() == TCalRRule::EDaily &&
+ origRRule.Interval() == 14)
+ {
+ // If old note's repeat is every 14 days,
+ // set repeat to every 14 days to Agenda, NOT every 2 weeks.
+ //
+ aRRule.SetType( TCalRRule::EDaily );
+ interval = 14;
+ }
+ else
+ {
+ aRRule.SetType( TCalRRule::EWeekly );
+ interval = 2;
+
+ RArray<TDay> dayArray;
+ CleanupClosePushL( dayArray );
+ dayArray.Append( aRRule.DtStart().TimeLocalL().DayNoInWeek() );
+ aRRule.SetByDay( dayArray );
+ CleanupStack::PopAndDestroy( &dayArray );
+ }
+ break;
+ }
+ case ERepeatWorkdays:// Weekly
+ {
+ TLocale iLocale;
+ TUint iWorkDays = iLocale.WorkDays();
+ if (hasOrigRRule && origRRule.Type() == TCalRRule::EDaily
+ && origRRule.Interval() == 7)
+ {
+ // If old note's repeat is every 7 days,
+ // set repeat to every 7 days to Agenda, NOT every week.
+ //
+ aRRule.SetType(TCalRRule::EDaily);
+ interval = 7;
+ }
+ else
+ {
+ aRRule.SetType(TCalRRule::EWeekly);
+ RArray<TDay> dayArray;
+ CleanupClosePushL(dayArray);
+ TInt fixedNum = 1;
+ TInt ruleday = 0;
+ for (TInt i =0 ; i < KNoOfDaysInWeek ; i++)
+ {
+ ruleday = fixedNum << i;
+ if(iWorkDays & ruleday)
+ {
+ dayArray.Append((TDay)i);
+ aRRule.SetByDay(dayArray);
+ }
+ }
+ CleanupStack::PopAndDestroy(&dayArray);
+ }
+ break;
+
+ }
+ case (ERepeatMonthly):
+ // Monthly By Position
+ {
+ aRRule.SetType( TCalRRule::EMonthly );
+
+ RArray<TInt> dateArray;
+ CleanupClosePushL( dateArray );
+ dateArray.Append( aRRule.DtStart().TimeLocalL().DayNoInMonth() );
+ aRRule.SetByMonthDay( dateArray );
+ CleanupStack::PopAndDestroy( &dateArray );
+
+ break;
+ }
+ case (ERepeatYearly): // Yearly
+ {
+ // If old note's repeat is every 12 months,
+ // set repeat to every 12 months to Agenda, NOT every year.
+ //
+ if ( hasOrigRRule && origRRule.Type() == TCalRRule::EMonthly &&
+ origRRule.Interval() == 12)
+ {
+ aRRule.SetType( TCalRRule::EMonthly );
+ interval = 12;
+ }
+ else
+ {
+ aRRule.SetType( TCalRRule::EYearly );
+ }
+ break;
+ }
+ default: // Repeat item is "Other"
+ {
+ interval = aRRule.Interval(); // To copy previous note's interval
+ break;
+ }
+ }
+
+ aRRule.SetInterval( interval );
+ }
+
+ // If repeat until is max date of Calendar,
+ // note repeat is set to forever.
+ if ( ! CalenDateUtils::IsValidDay(repeatUntil) || IsForeverDate( repeatUntil ) )
+ {
+ // Set repeat to forever:
+ aRRule.SetCount( 0 );
+ }
+ else
+ {
+ // Change repeatuntil so that hours, minutes, ... are same as in start date
+ TDateTime dtUntil = repeatUntil.DateTime();
+ TDateTime dtStart= iEntry.StartTimeL().TimeLocalL().DateTime();
+
+ dtUntil.Set( dtUntil.Year(), dtUntil.Month(), dtUntil.Day(),
+ dtStart.Hour(), dtStart.Minute(), dtStart.Second(), dtStart.MicroSecond());
+
+ TCalTime calRepeatUntil;
+ if ( UseFloatingTimeL() )
+ {
+ calRepeatUntil.SetTimeLocalFloatingL( TTime( dtUntil ) );
+ }
+ else
+ {
+ calRepeatUntil.SetTimeLocalL( TTime( dtUntil ) );
+ }
+ aRRule.SetUntil( calRepeatUntil );
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::SetDefaultNewValuesL
+// Sets the default values when creating a new entry.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::SetDefaultNewValuesL(CCalenEntryUtil& aData)
+ {
+ TRACE_ENTRY_POINT;
+
+ // FIXME: I don't know if this method should be needed or not.
+ // It's a bit unclear that if pass entry that is new,
+ // should we set default data in caller (application) or
+ // here.
+ // But to replicate old editor functionality, we set in editor
+ // side
+
+ ASSERT( IsCreatingNew() );
+ // start time and end time are taken from passed entry.
+ // They have to be initialized outside of editors
+
+ // subject, location, description are by default empty
+
+ // repeat rule is by default off
+
+ // alarm is by default off
+
+ // synch value
+ aData.SetSynchTypeL( CCalenEntryUtil::ESynchPrivate );
+
+ // priority
+ aData.SetPriorityL( CCalenEntryUtil::ETodoPriorityNormal );
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::IsChildL
+// Returns ETrue if the entry is a child, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::IsChildL() const
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return iRecurrenceId.TimeUtcL() != Time::NullTTime();
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::UseFloatingTimeL
+// Returns ETrue if the entry should use floating time, EFalse otherwise.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenEditorDataHandler::UseFloatingTimeL() const
+ {
+ TRACE_ENTRY_POINT;
+
+ // Use floating time based on type
+ // This way we ensure that entries _created_ with Calendar Editors
+ // are consistent regarding time mode.
+ //
+ TRACE_EXIT_POINT;
+ return (! IsTimedEntry()); // use floating time for non-timed entries
+
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::WriteStartAndEndTimesToEntryL
+// Writes the start and end times from the form to the CCalEntry.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::WriteStartAndEndTimesToEntryL( CalCommon::TRecurrenceRange aRepeatTarget )
+ {
+ TRACE_ENTRY_POINT;
+
+ const TBool unDatedTodo=(iEntry.EntryTypeL()==CCalEntry::ETodo) && (iEntry.EndTimeL().TimeLocalL()==Time::NullTTime());
+ const TBool unDatedTodoWithAlarm=unDatedTodo && (Edited().IsAlarmActivated());
+
+ TBool shouldWriteBothTimes =
+ // For new entries
+ IsCreatingNew() ||
+ // When creating exception entry (exception entry's time are read from editors)
+ ( aRepeatTarget != CalCommon::EThisAndAll ) ||
+ // when repeating entry is modified to be non-repeating (entry's times are read from editors)
+ ( Original().IsRepeating() && ! Edited().IsRepeating() );
+
+ if ( shouldWriteBothTimes || IsStartDateTimeEdited() || IsEndDateTimeEdited() || unDatedTodoWithAlarm )
+ {
+
+ TCalTime entryStart;
+ TCalTime entryEnd;
+
+ // 1) Initialize entryStart and entryEnd with original times.
+ // But for todos we need to be careful, because there might not be them originally
+ // In S60 UI, todos don't have starttime, so we use same for both start and end time.
+ if (iEntry.EntryTypeL()==CCalEntry::ETodo)
+ {
+ // if undated todo and it has alarm activated
+ if ((iEntry.EndTimeL().TimeLocalL()==Time::NullTTime()) && (Edited().IsAlarmActivated()))
+ {
+ entryStart.SetTimeLocalL(Edited().EventDateTime());
+ entryEnd.SetTimeLocalL(Edited().EventDateTime());
+ shouldWriteBothTimes=ETrue; // Ensures that times are written later
+ }
+ else
+ {
+ entryStart = iEntry.EndTimeL();
+ entryEnd = iEntry.EndTimeL();
+ }
+ }
+ else
+ {
+ entryStart = iEntry.StartTimeL();
+ entryEnd = iEntry.EndTimeL();
+ }
+
+ // 2) Decide start time
+ if ( shouldWriteBothTimes || IsStartDateTimeEdited() )
+ {
+ TTime newStart = Edited().StartDateTime();
+ TDateTime newStartDT = newStart.DateTime();
+ // Special case:
+ // In case c) only start time (hh:mm) of d) existing a) repeating b) series is edited,
+ // we need to preserve start date (dd.mm.yyy), because start date in editors
+ // is instance's start date.
+ // (Example of problematic cases that brings up, when UI represents
+ // two different concepts in same start date field)
+ // a) repeating b) series is edited c) only start time is edited d) existing
+ if ( Edited().IsRepeating() && aRepeatTarget == CalCommon::EThisAndAll && ! IsStartDateChanged() && ! IsCreatingNew() )
+ {
+ TDateTime oldDt = iEntry.StartTimeL().TimeLocalL().DateTime();
+ TDateTime editDt = newStart.DateTime();
+ newStart = TTime( TDateTime( oldDt.Year(), oldDt.Month(), oldDt.Day(),
+ editDt.Hour(), editDt.Minute(),
+ oldDt.Second(), oldDt.MicroSecond() ) );
+ }
+ else if ( ( Edited().RepeatType() == ERepeatOther ) && IsStartDateChanged() )
+ {
+ // The start time might have been disguised because the entry
+ // consists of an rRule and rDates. The actual start time
+ // needs to be extracted
+ RArray<TCalTime> rDates;
+ CleanupClosePushL( rDates );
+
+ iEntry.GetRDatesL( rDates );
+ if ( rDates.Count() > 0 )
+ {
+ // As we have rDates, check to see if there is an
+ // rRule
+ TCalRRule rRule;
+ if ( iEntry.GetRRuleL( rRule ) )
+ {
+ TTime firstRDate = rDates[ 0 ].TimeLocalL();
+ TTime rRuleStart = iEntry.StartTimeL().TimeLocalL();
+ TTime lastRDate = rDates[ rDates.Count() - 1 ].TimeLocalL();
+ TTimeIntervalMinutes startDateShiftInterval = 0;
+ if ( firstRDate < rRuleStart )
+ {
+ // The first rDate is before the start of the rRule
+ // So adjust the start date accordingly
+
+ User::LeaveIfError( newStart.MinutesFrom( firstRDate, startDateShiftInterval ) );
+ }
+ else
+ {
+ // The start of the rRule comes first
+ User::LeaveIfError( newStart.MinutesFrom( rRuleStart, startDateShiftInterval ) );
+ }
+
+ newStart = rRuleStart + startDateShiftInterval;
+
+ TInt rRuleCount = rRule.Count();
+ rRule.SetCount( rRuleCount );
+
+ TCalTime rRuleDT;
+ if ( UseFloatingTimeL() )
+ {
+ rRuleDT.SetTimeLocalFloatingL( newStart );
+ }
+ else
+ {
+ rRuleDT.SetTimeLocalL( newStart );
+ }
+
+ rRule.SetDtStart( rRuleDT );
+
+ // For rearranging the recurrence pattern for an
+ // entry having rdates
+
+ TInt repeatType = rRule.Type();
+ switch ( repeatType )
+ {
+ case ( TCalRRule::EWeekly ): //For Weekly repeating event
+ {
+ RArray<TDay> dayArray;
+ CleanupClosePushL( dayArray );
+ dayArray.Append( rRule.DtStart().TimeLocalL().DayNoInWeek() );
+ rRule.SetByDay( dayArray );
+ CleanupStack::PopAndDestroy( &dayArray );
+
+ // Adjust the RepeatUntil date
+ ApplyUntilDateToRRuleL( rRule, Edited().RepeatUntilDateTime() );
+ break;
+ }
+ case ( TCalRRule::EMonthly ):// For Monthly repeating event
+ {
+ RArray<TInt> dateArray;
+ CleanupClosePushL( dateArray );
+ dateArray.Append( rRule.DtStart().TimeLocalL().DayNoInMonth() );
+ rRule.SetByMonthDay( dateArray );
+ CleanupStack::PopAndDestroy( &dateArray );
+
+ // Adjust the RepeatUntil date
+ ApplyUntilDateToRRuleL( rRule, Edited().RepeatUntilDateTime() );
+ break;
+ }
+
+ case ( TCalRRule::EDaily ):// For Daily repeating event
+ {
+ TCalRRule curRule;
+ iEntry.GetRRuleL( curRule );
+
+ // Adjust the RepeatUntil date
+ if(lastRDate < curRule.Until().TimeLocalL() )
+ {
+ ApplyUntilDateToRRuleL( rRule, Edited().RepeatUntilDateTime() );
+ }
+
+
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+
+
+ iEntry.SetRRuleL( rRule );
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // rDates
+ }
+
+ if ( UseFloatingTimeL() )
+ {
+ entryStart.SetTimeLocalFloatingL( newStart );
+ }
+ else
+ {
+ entryStart.SetTimeLocalL( newStart );
+ }
+ }
+
+ // 3) Decide end time
+ if ( shouldWriteBothTimes || IsEndDateTimeEdited() )
+ {
+ TTime start = Edited().StartDateTime();
+ TTime end = Edited().EndDateTime();
+
+ // For all-day events, we add 24 hours to end date
+ // to make it full day long
+ /*if ( iEntryType == CCalEntry::EEvent)
+ {
+ end += TTimeIntervalDays(1);
+ }*/
+
+ TTimeIntervalMinutes duration;
+ TInt err = end.MinutesFrom( start, duration );
+ ASSERT( err == KErrNone );
+ ASSERT( duration >= TTimeIntervalMinutes(0) );
+
+ if ( UseFloatingTimeL() )
+ {
+ entryEnd.SetTimeLocalFloatingL( entryStart.TimeLocalL() + duration );
+ }
+ else
+ {
+ entryEnd.SetTimeLocalL( entryStart.TimeLocalL() + duration );
+ }
+ }
+
+ // If EntryType is changed as Non-timed/Timed entry, along with StartTime(AND/OR)EndTime,
+ // Both Start/End time TimeMode should be changed accordingly.
+ if ( UseFloatingTimeL() )
+ {
+ entryStart.SetTimeLocalFloatingL( entryStart.TimeLocalL() );
+ entryEnd.SetTimeLocalFloatingL( entryEnd.TimeLocalL() );
+ }
+ else
+ {
+ entryStart.SetTimeLocalL( entryStart.TimeLocalL() );
+ entryEnd.SetTimeLocalL( entryEnd.TimeLocalL() );
+ }
+
+ // Write times to entry
+ iEntry.SetStartAndEndTimeL( entryStart, entryEnd );
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+//----------------------------------------------------------------------
+// CCalenEditorDataHandler::ResetOriginalDataL
+// Reset original editor data
+// (other items were commented in a header).
+//----------------------------------------------------------------------
+void CCalenEditorDataHandler::ResetOriginalDataL()
+ {
+ TRACE_ENTRY_POINT;
+
+ if(iOriginal)
+ {
+ delete iOriginal;
+ iOriginal=NULL;
+ }
+ iOriginal = CCalenEntryUtil::NewL( iEntry, iInstanceDateTime );
+
+ TRACE_EXIT_POINT;
+ }
+
+//----------------------------------------------------------------------
+// CCalenEditorDataHandler::EntryViewL
+// Temp function to get to work
+// (other items were commented in a header).
+//----------------------------------------------------------------------
+CCalEntryView& CCalenEditorDataHandler::EntryViewL()
+ {
+ TRACE_ENTRY_POINT;
+
+ CCalEntryView* entryView = iServices.EntryViewL(CurrentDbCollectionId());
+
+ TRACE_EXIT_POINT;
+ return *entryView;
+ }
+
+//----------------------------------------------------------------------
+// CCalenEditorDataHandler::InstanceViewL
+// Temp function to get to work
+// (other items were commented in a header).
+//----------------------------------------------------------------------
+CCalInstanceView& CCalenEditorDataHandler::InstanceViewL()
+ {
+ TRACE_ENTRY_POINT;
+
+ CCalInstanceView* instanceView = iServices.InstanceViewL(iCollectionIds);
+
+ TRACE_EXIT_POINT;
+ return *instanceView;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::GetPreviousInstanceForRepeatOtherL()
+// Returns the time of the previous instance of a particular repeating entry
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TTime CCalenEditorDataHandler::GetPreviousInstanceForRepeatOtherL(CCalEntry& aEntry, const CalCommon::TCalTimeRange& timeRange)
+ {
+ RPointerArray<CCalInstance> allInstances;
+ CleanupResetAndDestroyPushL( allInstances );
+
+ TInt filter;
+ // Get the entry type to be filtered
+ switch(aEntry.EntryTypeL())
+ {
+ case CCalEntry::EAppt:
+ filter = CalCommon::EIncludeAppts;
+ break;
+ case CCalEntry::ETodo:
+ filter = CalCommon::EIncludeCompletedTodos | CalCommon::EIncludeIncompletedTodos;
+ break;
+ case CCalEntry::EEvent:
+ filter = CalCommon::EIncludeEvents;
+ break;
+ case CCalEntry::EReminder:
+ filter = CalCommon::EIncludeReminder;
+ break;
+ case CCalEntry::EAnniv:
+ filter = CalCommon::EIncludeAnnivs;
+ break;
+ default:
+ filter = CalCommon::EIncludeAll;
+ break;
+ };
+
+ iServices.InstanceViewL()->FindInstanceL( allInstances,
+ (CalCommon::TCalViewFilterFlags)filter,
+ timeRange);
+
+ TTime previousTime = Time::NullTTime();
+
+ for( TInt i = allInstances.Count() - 1; i >= 0; i-- )
+ {
+ if( allInstances[i]->Entry().UidL() == aEntry.UidL() )
+ {
+ TRACE_EXIT_POINT;
+ previousTime = allInstances[i]->Time().TimeLocalL();
+ break;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( &allInstances );
+ return previousTime;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::GetNextInstanceForRepeatOtherL()
+// Returns the time of the next instance of a particular repeating entry
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TTime CCalenEditorDataHandler::GetNextInstanceForRepeatOtherL( CCalEntry& aEntry, const CalCommon::TCalTimeRange& timeRange )
+ {
+ RPointerArray<CCalInstance> allInstances;
+ CleanupResetAndDestroyPushL( allInstances );
+
+ TInt filter;
+ // Get the entry type to be filtered
+ switch( aEntry.EntryTypeL() )
+ {
+ case CCalEntry::EAppt:
+ filter = CalCommon::EIncludeAppts;
+ break;
+ case CCalEntry::ETodo:
+ filter = CalCommon::EIncludeCompletedTodos | CalCommon::EIncludeIncompletedTodos;
+ break;
+ case CCalEntry::EEvent:
+ filter = CalCommon::EIncludeEvents;
+ break;
+ case CCalEntry::EReminder:
+ filter = CalCommon::EIncludeReminder;
+ break;
+ case CCalEntry::EAnniv:
+ filter = CalCommon::EIncludeAnnivs;
+ break;
+ default:
+ filter = CalCommon::EIncludeAll;
+ break;
+ };
+
+ iServices.InstanceViewL()->FindInstanceL( allInstances,
+ ( CalCommon::TCalViewFilterFlags )filter,
+ timeRange);
+
+ TTime nextTime = Time::NullTTime();
+
+ TInt i( 0 );
+ for( ; i < allInstances.Count(); i++ )
+ {
+ if( allInstances[i]->Entry().UidL() == aEntry.UidL() )
+ {
+ TRACE_EXIT_POINT;
+ nextTime = allInstances[i]->Time().TimeLocalL();
+ break;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( &allInstances );
+ return nextTime;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::SetEntryType
+// add attachments to the entry as ccalattachments
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::SetEntryType( CCalEntry::TType aNewEntryType )
+ {
+ iEntryType = aNewEntryType;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::AddAttachementsToEntryL
+// add attachments to the entry as ccalattachments
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::AddAttachementsToEntryL()
+ {
+ TRACE_ENTRY_POINT;
+
+ // Get the list of attachments from model and add them to entry
+ RPointerArray<CCalenAttachmentInfo> attachmentInfoList;
+ iServices.GetAttachmentData()->GetAttachmentListL( attachmentInfoList );
+ TInt attachmentCount = iEntry.AttachmentCountL();
+ TInt modelCount = attachmentInfoList.Count();
+
+ if( attachmentCount > 0 && modelCount == 0 )
+ {
+ // This means that all the attachments in the entry have been deleted
+ // by the user. So remove all attchments from the entry
+ for( int index = 0 ; index < attachmentCount ; index++ )
+ {
+ iEntry.DeleteAttachmentL( *iEntry.AttachmentL( 0 ) );
+ }
+
+ // No attachments need to be added at this point, we can simply return.
+ attachmentInfoList.Close();
+ TRACE_EXIT_POINT;
+ return;
+ }
+
+ // Delete all the attachmenst of the entry which are not present in the model
+ TInt currentIndex = 0;
+ for( TInt index=0; index < attachmentCount; index++ )
+ {
+ CCalAttachment* attachment = iEntry.AttachmentL( currentIndex );
+ TBool matchFound = EFalse;
+ for( int modelIndex = 0 ; modelIndex < modelCount ; modelIndex++ )
+ {
+ CCalenAttachmentInfo* attachmentInfo = attachmentInfoList[ modelIndex ];
+ if( attachmentInfo->StoreType() ==
+ CCalenAttachmentInfo::ECalenAttachmentFetchedFromEntry )
+ {
+ // We are only interested in those attachments which have been
+ // fetched from the entry because any newly added attachments
+ // will not yet be updated in the entry
+ RFile attachmentHandle;
+ CleanupClosePushL( attachmentHandle );
+ attachment->FileAttachment()->FetchFileHandleL( attachmentHandle );
+
+ TFileName systemFileName;
+ attachmentHandle.FullName( systemFileName );
+
+ if( systemFileName == attachmentInfo->SystemFileName() )
+ {
+ // There is an attachment in the model which matches the
+ // attachment in the entry. So do not delete it
+ matchFound = ETrue;
+ CleanupStack::PopAndDestroy( &attachmentHandle );
+ break;
+ }
+ CleanupStack::PopAndDestroy( &attachmentHandle );
+ }
+ }
+ if( !matchFound )
+ {
+ // There is no matching attachment in the model. Delete it from entry
+ // This will compress the attachment array. Hence do not increment the currentIndex
+ iEntry.DeleteAttachmentL( *iEntry.AttachmentL( currentIndex ) );
+ }
+ else
+ {
+ // Move to the next attachment
+ currentIndex++;
+ }
+ }
+
+ // Now add the remaining newly added attachments to the entry
+ for( TInt index=0 ; index< modelCount ; index++ )
+ {
+ CCalenAttachmentInfo* attachmentInfo = attachmentInfoList[ index ];
+ if( attachmentInfo->StoreType() == CCalenAttachmentInfo::ECalenNewAttachment )
+ {
+ TParsePtrC fileNameParser(attachmentInfo->FileName());
+ RFile fileHandle;
+ CEikonEnv* eikonEnv = CEikonEnv::Static();
+ RFs& fs = eikonEnv->FsSession();
+ User::LeaveIfError(fs.ShareProtected());
+
+ TInt err = fileHandle.Open( fs, attachmentInfo->FileName(), EFileWrite );
+ if( KErrNone != err )
+ {
+ attachmentInfoList.Close();
+ TRACE_EXIT_POINT;
+ return;
+ }
+ CleanupClosePushL(fileHandle);
+
+ CCalAttachment* attachment = CCalAttachment::NewFileL(fileHandle);
+ CleanupStack::PopAndDestroy(&fileHandle);
+
+ CleanupStack::PushL( attachment );
+ // Sets the label for the attachment
+ attachment->SetLabelL( fileNameParser.NameAndExt() );
+ // Sets mime type for the attachment
+ attachment->SetMimeTypeL( attachmentInfo->DataType().Des8() );
+ attachment->SetAttribute(CCalAttachment::EExportInline);
+ iEntry.AddAttachmentL( *attachment );
+ CleanupStack::Pop( attachment );
+ }
+ }
+ attachmentInfoList.Close();
+
+ TRACE_EXIT_POINT;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::SetCalendarFieldEditedL
+// Set if calendar is been edited or not with previous and current collection id
+// -----------------------------------------------------------------------------
+//
+void CCalenEditorDataHandler::SetCalendarFieldEditedL(TBool aEdited ,
+ TCalCollectionId aPreviousDbColId,
+ TCalCollectionId aCurrentDbColId)
+ {
+ TRACE_ENTRY_POINT
+ iCalendarFieldEdited = aEdited;
+ iPreviousDbColId = aPreviousDbColId;
+ iCurrentDbColId = aCurrentDbColId;
+ TRACE_EXIT_POINT
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::PreviousDbCollectionId
+// Get previous collection id
+// -----------------------------------------------------------------------------
+//
+TCalCollectionId CCalenEditorDataHandler::PreviousDbCollectionId()
+ {
+ TRACE_ENTRY_POINT
+ TRACE_EXIT_POINT
+ return iPreviousDbColId;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::CurrentDbCollectionId
+// Get current collection id
+// -----------------------------------------------------------------------------
+//
+TCalCollectionId CCalenEditorDataHandler::CurrentDbCollectionId()
+ {
+ TRACE_ENTRY_POINT
+ TRACE_EXIT_POINT
+ return iCurrentDbColId;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenEditorDataHandler::CalenInstanceId
+// Returns the instance id.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+const TCalenInstanceId CCalenEditorDataHandler::CalenInstanceId()
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+
+ return iInstanceId;
+ }
+
+// End of file --Don't remove this.