FCL/sf/app/commonemail: comparison meetingrequest/mrgui/src/cesmrmeetingtimevalidator.cpp

equal deleted inserted replaced

-:0396474f30f5
+:4ce476e64c59
 /*
-* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 #include "cesmrglobalnote.h"
 #include "mesmrfieldstorage.h"
 #include "mesmrcalentry.h"
 #include "mesmrmeetingrequestentry.h"
 #include "mesmrfieldeventqueue.h"
+#include "mmrabsolutealarmcontroller.h"
 #include "cesmrgenericfieldevent.h"
+#include "cesmrrecurrenceinfoHandler.h"
 // Unnamed namespace for local definitions
 namespace { // codescanner::namespace
 // Definition fom max possible time
 }
 else if ( aTime > KMaxTTime )
 {
 aTime = KMaxTTime;
 }
-if ( aEditor.IsVisible() )
+aEditor.SetTime( aTime );
-{
-aEditor.SetTime( aTime );
-}
 }
 /**
 * Sets date to editor. Date is checked and adjusted
 * between min and max before setting
 else if ( aDate > KMaxTTime )
 {
 aDate = KMaxTTime;
 }
-if ( aEditor.IsVisible() )
+aEditor.SetDate( aDate );
-{
+}
-aEditor.SetDate( aDate );
-}
+/**
+* Compares two times and returns ETrue if they have same date components
+* @param aLhs Left hand side component
+* @param aRhs Right hand side component
+*/
+TBool IsSameDay(
+const TDateTime& aLhs,
+const TDateTime& aRhs )
+{
+TBool retValue(EFalse);
+if ( aLhs.Day() == aRhs.Day() &&
+aLhs.Month() == aRhs.Month() &&
+aLhs.Year() == aRhs.Year()   )
+{
+retValue = ETrue;
+}
+return retValue;
 }
 } // namespace
 // ======== MEMBER FUNCTIONS ========
 {
 TDateTime startDt = startTime.DateTime();
 TDateTime endDt = endTime.DateTime();
 if ( startDt.Day() != endDt.Day() ||
 startDt.Month() != endDt.Month() ||
 startDt.Year() != endDt.Year() )
 {
 error = MESMRFieldValidator::EErrorRecDifferetStartAndEnd;
 }
 if ( KErrorNone == error &&
 static_cast<MESMRMeetingRequestEntry*>( iEntry );
 if ( mrEntry->IsRecurrentEventL() &&
 MESMRCalEntry::EESMRThisOnly == mrEntry->RecurrenceModRule() )
 {
 TBool instanceAlreadyOnThisDay(
-mrEntry->AnyInstanceOnDayL(startTime, endTime) );
+mrEntry->AnyInstancesBetweenTimePeriodL(
+		   startTime,
+		   endTime ) );
 if ( instanceAlreadyOnThisDay )
 {
 error = MESMRFieldValidator::EErrorRescheduleInstance;
 }
 }
 }
+if (  KErrorNone == error &&
+MESMRCalEntry::EESMRCalEntryMeeting == iEntry->Type() )
+{
+// Check that is modified entry
+if ( iEntry->IsRecurrentEventL() &&
+MESMRCalEntry::EESMRThisOnly == iEntry->RecurrenceModRule() )
+{
+TBool instanceAlreadyOnThisDay(
+iEntry->AnyInstancesBetweenTimePeriodL(
+		   startTime,
+		   endTime ) );
+if ( instanceAlreadyOnThisDay )
+{
+error = MESMRFieldValidator::EErrorRescheduleInstance;
+}
+}
+}
+if (  KErrorNone == error &&
+( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() ||
+MESMRCalEntry::EESMRCalEntryMeeting == iEntry->Type() ) )
+{
+// Check that is modified entry
+if ( iEntry->IsRecurrentEventL() &&
+MESMRCalEntry::EESMRThisOnly == iEntry->RecurrenceModRule() )
+{
+error = ValidateEditedInstanceTimeL();
+}
+}
 if ( KErrorNone == error && iAlldayEvent && iAlarmOnOff )
 {
 TTime alarmTime = AlarmDateTime();
 if ( alarmTime > startTime )
 error = MESMRFieldValidator::EErrorRelativeAlarmInPast;
 }
 TTime until;
 if ( iRecurrenceValue != ERecurrenceNot &&
-iRecurrenceValue != ERecurrenceUnknown &&
+iRecurrenceValue != ERecurrenceUnknown )
-iRecurrenceUntilDate && iRecurrenceUntilDate->IsVisible() )
 {
 until = RecurrenceUntilTime();
 // Showing error note if is alarm in past,
 // when entry has recurrence
 }
 return error;
 }
 // ---------------------------------------------------------------------------
+// CESMRMeetingTimeValidator::ValidateEditedInstanceTimeL
+// ---------------------------------------------------------------------------
+//
+MESMRFieldValidator::TESMRFieldValidatorError CESMRMeetingTimeValidator::ValidateEditedInstanceTimeL()
+{
+CESMRRecurrenceInfoHandler* recurrenceHandler =
+CESMRRecurrenceInfoHandler::NewLC( iEntry->Entry(), &iEntry->GetDBMgr() );
+TCalTime preStartTime;
+TCalTime preEndTime;
+TCalTime nextStartTime;
+TCalTime nextEndTime;
+CCalInstance* instance = iEntry->InstanceL();
+CleanupStack::PushL( instance );
+TTime instanceDateTime = instance->StartTimeL().TimeLocalL();
+CleanupStack::PopAndDestroy( instance );
+recurrenceHandler->GetPreviousInstanceTimeL( preStartTime, preEndTime, instanceDateTime );
+recurrenceHandler->GetNextInstanceTimeL( nextStartTime, nextEndTime, instanceDateTime );
+CleanupStack::PopAndDestroy( recurrenceHandler );
+const TTime editedStartDateTime( StartDateTime() );
+const TTime editedEndDateTime( EndDateTime() );
+if( preStartTime.TimeLocalL() != Time::NullTTime() )
+{
+// Does the exception end on/after prevEnd?
+if( editedStartDateTime < preEndTime.TimeLocalL() )
+{
+// Does the exception start after prevStart?
+if( editedStartDateTime > preStartTime.TimeLocalL() )
+{
+return EErrorInstanceOverlapsExistingOne;
+}
+else
+{
+// Does the exception finish after prevStart?
+if( editedEndDateTime > preStartTime.TimeLocalL() )
+{
+return EErrorInstanceOverlapsExistingOne;
+}
+else
+{
+return EErrorInstanceOutOfSequence;
+}
+}
+}
+// Does the exception start on the same day as prevStart?
+if( IsSameDay( StartDateTime(), preStartTime.TimeLocalL().DateTime() ) )
+{
+return EErrorInstanceAlreadyExistsOnThisDay;
+}
+}
+if( nextStartTime.TimeLocalL() != Time::NullTTime() )
+{
+// Does the exception finish on/before nextStart?
+if( editedEndDateTime > nextStartTime.TimeLocalL() )
+{
+// Does the exception finish before nextFinish?
+if( editedEndDateTime < nextEndTime.TimeLocalL() )
+{
+return EErrorInstanceOverlapsExistingOne;
+}
+else
+{
+// Does the exception start before nextFinish?
+if( editedStartDateTime < nextEndTime.TimeLocalL() )
+{
+return EErrorInstanceOverlapsExistingOne;
+}
+else
+{
+return EErrorInstanceOutOfSequence;
+}
+}
+}
+// Does the exception start on the same day as nextStart?
+if( IsSameDay( StartDateTime(), nextStartTime.TimeLocalL().DateTime() ) )
+{
+return EErrorInstanceAlreadyExistsOnThisDay;
+}
+}
+// Does the series have any rdates
+RArray<TCalTime> rDateArray;
+CleanupClosePushL( rDateArray );
+iEntry->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
+TTimeIntervalMinutes duration;
+editedStartDateTime.MinutesFrom( editedEndDateTime, duration );
+for ( TInt index = 0; index < rDateCount; index++ )
+{
+const TTime& rDate = rDateArray[ index ].TimeLocalL();
+if ( !IsSameDay( iEntry->Entry().StartTimeL().TimeLocalL().DateTime(), rDate.DateTime() ) )
+{
+// Does the exception start or end on the same day as a rdate.
+if ( IsSameDay( StartDateTime(), rDate.DateTime() ) )
+{
+CleanupStack::PopAndDestroy(); // rDateArray
+return EErrorInstanceAlreadyExistsOnThisDay;
+}
+// Does the exception overlap an rdate?
+TTime rDateEnd = rDate + duration;
+if ( editedEndDateTime > rDateEnd && editedStartDateTime < rDate )
+{
+CleanupStack::PopAndDestroy(); // rDateArray
+return EErrorInstanceOverlapsExistingOne;
+}
+}
+}
+}
+CleanupStack::PopAndDestroy(); // rDateArray
+return EErrorNone;
+}
+// ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::ReadValuesFromEntryL
 // ---------------------------------------------------------------------------
 //
 void CESMRMeetingTimeValidator::ReadValuesFromEntryL(
 MESMRCalEntry& aEntry )
 SetTimeToEditor( *iEndTime, end );
 SetDateToEditor( *iEndDate, end );
 ReadAlarmFromEntryL( entry );
 ReadRecurrenceFromEntryL( aEntry );
 DrawEditorsDeferred();
+SendFieldChangeEventL( EESMRFieldStartDate );
 }
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::StoreValuesToEntryL
 // ---------------------------------------------------------------------------
 {
 entry.SetAlarmL( NULL );
 }
 }
 if ( ERecurrenceNot != iRecurrenceValue &&
 ERecurrenceUnknown != iRecurrenceValue )
 {
 aEntry.SetRecurrenceL(
 iRecurrenceValue,
 void CESMRMeetingTimeValidator::SetStartTimeFieldL(
 CEikTimeEditor& aStartTime )
 {
 FUNC_LOG;
 iStartTime = &aStartTime;
+if ( Time::NullTTime() != iCurrentStartTime )
+{
+SetTimeToEditor( *iStartTime, iCurrentStartTime );
+}
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::SetEndTimeFieldL
 // ---------------------------------------------------------------------------
 void CESMRMeetingTimeValidator::SetEndTimeFieldL(
 CEikTimeEditor& aEndTime )
 {
 FUNC_LOG;
 iEndTime = &aEndTime;
+if ( Time::NullTTime() != iCurrentEndTime )
+{
+SetTimeToEditor( *iEndTime, iCurrentEndTime );
+}
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::SetStartDateFieldL
 // ---------------------------------------------------------------------------
 void CESMRMeetingTimeValidator::SetStartDateFieldL(
 CEikDateEditor& aStartDate )
 {
 FUNC_LOG;
 iStartDate = &aStartDate;
+if ( Time::NullTTime() != iCurrentStartTime )
+{
+SetDateToEditor( *iStartDate, iCurrentStartTime );
+}
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::SetEndDateFieldL
 // ---------------------------------------------------------------------------
 void CESMRMeetingTimeValidator::SetEndDateFieldL(
 CEikDateEditor& aEndTime )
 {
 FUNC_LOG;
 iEndDate = &aEndTime;
+if ( Time::NullTTime() != iCurrentEndTime )
+{
+SetDateToEditor( *iEndDate, iCurrentEndTime );
+}
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::SetAlarmTimeFieldL
 // ---------------------------------------------------------------------------
 //
 void CESMRMeetingTimeValidator::SetAlarmTimeFieldL(
 CEikTimeEditor& aAlarmTime )
 {
 FUNC_LOG;
 iAlarmTime = &aAlarmTime;
+if ( iAlarmOnOff )
+{
+SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );
+}
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::SetAlarmDateFieldL
 // ---------------------------------------------------------------------------
 void CESMRMeetingTimeValidator::SetAlarmDateFieldL(
 CEikDateEditor& aAlarmDate )
 {
 FUNC_LOG;
 iAlarmDate = &aAlarmDate;
-}
+if ( iAlarmOnOff )
-// ---------------------------------------------------------------------------
+{
-// CESMRMeetingTimeValidator::StartTimeChangedL
+SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );
+}
+}
+// ---------------------------------------------------------------------------
+// CESMRMeetingTimeValidator::SetRecurrenceUntilDateFieldL
 // ---------------------------------------------------------------------------
 //
 void CESMRMeetingTimeValidator::SetRecurrenceUntilDateFieldL(
 CEikDateEditor& aRecurrenceUntil )
 {
 FUNC_LOG;
 iRecurrenceUntilDate = &aRecurrenceUntil;
+if ( Time::NullTTime() != iCurrentRecurrenceUntil )
+{
+SetDateToEditor( *iRecurrenceUntilDate, iCurrentRecurrenceUntil );
+}
+}
+// ---------------------------------------------------------------------------
+// CESMRMeetingTimeValidator::SetAbsoluteAlarmOnOffFieldL
+// ---------------------------------------------------------------------------
+//
+void CESMRMeetingTimeValidator::SetAbsoluteAlarmOnOffFieldL(
+MMRAbsoluteAlarmController& aAbsoluteAlarmController )
+{
+FUNC_LOG;
+iAbsoluteAlarmController = &aAbsoluteAlarmController;
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::StartTimeChangedL
 // ---------------------------------------------------------------------------
 SetTimeToEditor( *iEndTime, iCurrentEndTime );
 SetDateToEditor( *iEndDate, iCurrentEndTime );
 }
 DrawEditorsDeferred();
 User::LeaveIfError( err );
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::AlarmTimeChangedL
 void CESMRMeetingTimeValidator::SetAlarmOnOffL(
 TBool aAlarmOn )
 {
 FUNC_LOG;
 iAlarmOnOff = aAlarmOn;
+if( iAlarmOnOff )
+{
+iAbsoluteAlarmController->SetAbsoluteAlarmOn();
+}
+else
+{
+iAbsoluteAlarmController->SetAbsoluteAlarmOff();
+}
 if ( iAlarmOnOff && iAlldayEvent )
 {
-TTime nullTime = Time::NullTTime();
 if ( iCurrentAlarmTime > iCurrentStartTime ||
-iCurrentAlarmTime == nullTime )
+iCurrentAlarmTime == Time::NullTTime() )
 {
 iCurrentAlarmTime =
 				DefaultAlldayEventAlarmTime( iCurrentStartTime );
 SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );
 SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );
 {
 iEndDate->PrepareForFocusLossL();
 }
 if ( iAlarmOnOff && iAlarmTime && iAlldayEvent && iAlarmTime->IsVisible() )
 {
-TDateTime dt = iAlarmTime->Time().DateTime();
 iAlarmTime->PrepareForFocusLossL();
 }
 if ( iAlarmOnOff && iAlarmDate && iAlldayEvent && iAlarmDate->IsVisible() )
 {
 iAlarmDate->PrepareForFocusLossL();
 // ---------------------------------------------------------------------------
 //
 void CESMRMeetingTimeValidator::HandleStartTimeChangeL()
 {
 FUNC_LOG;
+TInt err( KErrNone );
 TTime startTime = StartDateTime();
 TTime endTime   = EndDateTime();
 SetTimeToEditor( *iStartTime, startTime );
 SetDateToEditor( *iStartDate, startTime );
 User::LeaveIfError(
 startTime.MinutesFrom(
 iCurrentStartTime,
 startTimeChange ) );
-endTime += startTimeChange;
+if ( startTimeChange.Int() )
+{
+endTime += startTimeChange;
+if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )
+{
+MESMRMeetingRequestEntry* mrEntry =
+static_cast<MESMRMeetingRequestEntry*>( iEntry );
+if ( mrEntry->IsRecurrentEventL() &&
+MESMRCalEntry::EESMRThisOnly == mrEntry->RecurrenceModRule() )
+{
+TBool instanceAlreadyOnThisDay(
+mrEntry->AnyInstancesBetweenTimePeriodL(startTime, endTime) );
+if ( instanceAlreadyOnThisDay )
+{
+// Restore previous time
+SetTimeToEditor( *iStartTime, iCurrentStartTime );
+SetDateToEditor( *iStartDate, iCurrentStartTime );
+err = KErrOverflow;
+}
+else
+{
+TTime firstInstanceStart;
+TTime firstInstanceEnd;
+mrEntry->GetFirstInstanceStartAndEndTimeL(
+firstInstanceStart,
+firstInstanceEnd );
+if ( startTime < firstInstanceStart )
+{
+SetTimeToEditor( *iStartTime, iCurrentStartTime );
+SetDateToEditor( *iStartDate, iCurrentStartTime );
+err = KErrUnderflow;
+}
+}
+}
+}
+if ( MESMRCalEntry::EESMRCalEntryMeeting == iEntry->Type() )
+			{
+			if ( iEntry->IsRecurrentEventL() &&
+				 MESMRCalEntry::EESMRThisOnly == iEntry->RecurrenceModRule() )
+				{
+				TBool instanceAlreadyOnThisDay(
+						   iEntry->AnyInstancesBetweenTimePeriodL(
+								   startTime,
+								   endTime ) );
+				if ( instanceAlreadyOnThisDay )
+					{
+					// Restore previous time
+					SetTimeToEditor( *iStartTime, iCurrentStartTime );
+					SetDateToEditor( *iStartDate, iCurrentStartTime );
+					err = KErrOverflow;
+					}
+				else
+					{
+					TTime firstInstanceStart;
+					TTime firstInstanceEnd;
+					iEntry->GetFirstInstanceStartAndEndTimeL(
+							firstInstanceStart,
+							firstInstanceEnd );
+					if ( startTime < firstInstanceStart )
+						{
+						SetTimeToEditor( *iStartTime, iCurrentStartTime );
+						SetDateToEditor( *iStartDate, iCurrentStartTime );
+						err = KErrUnderflow;
+						}
+					}
+				}
+			}
+if ( KErrNone == err )
+{
+SetTimeToEditor( *iEndTime, endTime );
+SetDateToEditor( *iEndDate, endTime );
+iCurrentStartTime = startTime;
+iCurrentEndTime = endTime;
+if ( iAlldayEvent && iAlarmOnOff &&
+iAlarmTime->IsVisible() && iAlarmDate->IsVisible() )
+{
+TTime alarmTime = AlarmDateTime();
+alarmTime += startTimeChange;
+SetTimeToEditor( *iAlarmTime, alarmTime );
+SetDateToEditor( *iAlarmDate, alarmTime );
+iCurrentAlarmTime = alarmTime;
+}
+if ( ERecurrenceNot != iRecurrenceValue &&
+iRecurrenceUntilDate && iRecurrenceUntilDate->IsVisible() )
+{
+TTime recUntil = RecurrenceUntilTime();
+if ( startTime.DateTime().Day() != iComparativeStartTime.Day() ||
+startTime.DateTime().Month() != iComparativeStartTime.Month() ||
+startTime.DateTime().Year() != iComparativeStartTime.Year() )
+{
+// We want to update the recurrence until only when
+// a) Day, b) Month, c) or Year of the start time has changed
+recUntil += startTimeChange;
+iComparativeStartTime = startTime.DateTime();
+}
+SetDateToEditor( *iRecurrenceUntilDate, recUntil );
+iCurrentRecurrenceUntil = recUntil;
+}
+}
+}
-if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )
+DrawEditorsDeferred();
-{
+User::LeaveIfError( err );
-MESMRMeetingRequestEntry* mrEntry =
-static_cast<MESMRMeetingRequestEntry*>( iEntry );
-if ( mrEntry->IsRecurrentEventL() &&
-MESMRCalEntry::EESMRThisOnly == mrEntry->RecurrenceModRule() )
-{
-TBool instanceAlreadyOnThisDay(
-mrEntry->AnyInstanceOnDayL(startTime, endTime) );
-if ( instanceAlreadyOnThisDay )
-{
-// Restore previous time
-SetTimeToEditor( *iStartTime, iCurrentStartTime );
-SetDateToEditor( *iStartDate, iCurrentStartTime );
-User::Leave( KErrOverflow );
-}
-}
-}
-SetTimeToEditor( *iEndTime, endTime );
-SetDateToEditor( *iEndDate, endTime );
-iCurrentStartTime = startTime;
-iCurrentEndTime = endTime;
-if ( iAlldayEvent && iAlarmOnOff &&
-iAlarmTime->IsVisible() && iAlarmDate->IsVisible() )
-{
-TTime alarmTime = AlarmDateTime();
-alarmTime += startTimeChange;
-SetTimeToEditor( *iAlarmTime, alarmTime );
-SetDateToEditor( *iAlarmDate, alarmTime );
-iCurrentAlarmTime = alarmTime;
-}
-if ( ERecurrenceNot != iRecurrenceValue &&
-iRecurrenceUntilDate && iRecurrenceUntilDate->IsVisible() )
-{
-TTime recUntil = RecurrenceUntilTime();
-if ( startTime.DateTime().Day() != iComparativeStartTime.Day() ||
-startTime.DateTime().Month() != iComparativeStartTime.Month() ||
-startTime.DateTime().Year() != iComparativeStartTime.Year() )
-{
-// We want to update the recurrence until only when
-// a) Day, b) Month, c) or Year of the start time has changed
-recUntil += startTimeChange;
-iComparativeStartTime = startTime.DateTime();
-}
-SetDateToEditor( *iRecurrenceUntilDate, recUntil );
-iCurrentRecurrenceUntil = recUntil;
-}
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::HandleEndTimeChangeL
 // ---------------------------------------------------------------------------
 void CESMRMeetingTimeValidator::HandleEndTimeChangeL()
 {
 FUNC_LOG;
 TInt err( KErrNone );
 TTime startTime = StartDateTime();
-TTime endTime   = EndDateTime();
+TTime endTime = EndDateTime();
-if ( !iAlldayEvent && endTime < startTime )
+// Check first if end time has even changed
-{
+TTimeIntervalMinutes endTimeChange;
-if( ERecurrenceNot != iRecurrenceValue )
+User::LeaveIfError(
-{
+endTime.MinutesFrom(
-err = KErrArgument;
+iCurrentEndTime,
-}
+endTimeChange ) );
-else
-{
+if ( endTimeChange.Int() )
-// End time is earlier than start time
+{
-// and this is not allday event.
+if ( !iAlldayEvent && endTime < startTime )
-endTime += TTimeIntervalDays( KOne );
+{
-}
+if( ERecurrenceNot != iRecurrenceValue )
-}
+{
+err = KErrArgument;
-if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )
+}
-{
+else
-// Check that is modified entry
+{
-MESMRMeetingRequestEntry* mrEntry =
+// End time is earlier than start time
-static_cast<MESMRMeetingRequestEntry*>( iEntry );
+// and this is not allday event.
-if ( mrEntry->IsRecurrentEventL() &&
+endTime += TTimeIntervalDays( KOne );
-MESMRCalEntry::EESMRThisOnly == mrEntry->RecurrenceModRule() )
+}
-{
+}
-TBool instanceAlreadyOnThisDay(
-mrEntry->AnyInstanceOnDayL(startTime, endTime) );
+if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )
+{
-if ( instanceAlreadyOnThisDay )
+// Check that is modified entry
-{
+MESMRMeetingRequestEntry* mrEntry =
-// Restore previous time
+static_cast<MESMRMeetingRequestEntry*>( iEntry );
-SetTimeToEditor( *iStartTime, iCurrentStartTime );
+if ( mrEntry->IsRecurrentEventL() &&
-SetDateToEditor( *iStartDate, iCurrentStartTime );
+MESMRCalEntry::EESMRThisOnly == mrEntry->RecurrenceModRule() )
+{
+TBool instanceAlreadyOnThisDay(
+mrEntry->AnyInstancesBetweenTimePeriodL(startTime, endTime) );
-err = KErrOverflow;
+if ( instanceAlreadyOnThisDay )
-}
+{
-}
+// Restore previous time
-}
+SetTimeToEditor( *iStartTime, iCurrentStartTime );
+SetDateToEditor( *iStartDate, iCurrentStartTime );
+err = KErrOverflow;
+}
+else
+{
+TTime firstInstanceStart;
+TTime firstInstanceEnd;
+mrEntry->GetFirstInstanceStartAndEndTimeL(
+firstInstanceStart,
+firstInstanceEnd );
+if ( startTime < firstInstanceStart )
+{
+// Restore previous time
+SetTimeToEditor( *iStartTime, iCurrentStartTime );
+SetTimeToEditor( *iEndTime, iCurrentEndTime );
+err = KErrUnderflow;
+}
+}
+}
+}
+if ( MESMRCalEntry::EESMRCalEntryMeeting == iEntry->Type() )
+			{
+			// Check that is modified entry
+			if ( iEntry->IsRecurrentEventL() &&
+				 MESMRCalEntry::EESMRThisOnly == iEntry->RecurrenceModRule() )
+				{
+				TBool instanceAlreadyOnThisDay(
+						   iEntry->AnyInstancesBetweenTimePeriodL(
+								   startTime,
+								   endTime ) );
+				if ( instanceAlreadyOnThisDay )
+					{
+					// Restore previous time
+					SetTimeToEditor( *iStartTime, iCurrentStartTime );
+					SetDateToEditor( *iStartDate, iCurrentStartTime );
+					err = KErrOverflow;
+					}
+				else
+					{
+					TTime firstInstanceStart;
+					TTime firstInstanceEnd;
+					iEntry->GetFirstInstanceStartAndEndTimeL(
+							firstInstanceStart,
+							firstInstanceEnd );
+					if ( startTime < firstInstanceStart )
+						{
+						// Restore previous time
+						SetTimeToEditor( *iStartTime, iCurrentStartTime );
+						SetTimeToEditor( *iEndTime, iCurrentEndTime );
+						err = KErrUnderflow;
+						}
+					}
+				}
+			}
+if ( KErrNone == err )
+{
+iCurrentStartTime = startTime;
+iCurrentEndTime = endTime;
+}
-if ( KErrNone == err )
+if ( !iAlldayEvent )
 {
-iCurrentStartTime = startTime;
+SetTimeToEditor( *iStartTime, iCurrentStartTime );
-iCurrentEndTime = endTime;
+SetTimeToEditor( *iEndTime, iCurrentEndTime );
 }
-if ( !iAlldayEvent )
+SetDateToEditor( *iStartDate, iCurrentStartTime );
-{
+SetDateToEditor( *iEndDate, iCurrentEndTime );
-SetTimeToEditor( *iStartTime, iCurrentStartTime );
-SetTimeToEditor( *iEndTime, iCurrentEndTime );
+DrawEditorsDeferred();
-}
+User::LeaveIfError( err );
+}
-SetDateToEditor( *iStartDate, iCurrentStartTime );
-SetDateToEditor( *iEndDate, iCurrentEndTime );
-User::LeaveIfError( err );
 }
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::HandleAlarmTimeChangedL
 // ---------------------------------------------------------------------------
 {
 TTime start = StartDateTime();
 TTime minTimeForRecurrenceEnd =
 TimeForNextInstaceStartTime( iRecurrenceValue, start );
-TDateTime a = iCurrentRecurrenceUntil.DateTime();
+if ( Time::NullTTime() == iCurrentRecurrenceUntil ||
-TDateTime b = minTimeForRecurrenceEnd.DateTime();
+iCurrentRecurrenceUntil < minTimeForRecurrenceEnd )
-if ( iCurrentRecurrenceUntil < minTimeForRecurrenceEnd )
 {
 iCurrentRecurrenceUntil = minTimeForRecurrenceEnd;
 }
 }
 else
 {
 iCurrentRecurrenceUntil = StartDateTime();
 }
 if ( iRecurrenceUntilDate )
 {
 SetDateToEditor( *iRecurrenceUntilDate, iCurrentRecurrenceUntil );
 }
 }
 iCurrentRecurrenceUntil = recurrenceUntilTime;
 }
 if ( iRecurrenceUntilDate )
 {
-SetDateToEditor( *iRecurrenceUntilDate, iCurrentRecurrenceUntil );
+SetDateToEditor(
+*iRecurrenceUntilDate,
+iCurrentRecurrenceUntil );
 }
 User::LeaveIfError( err );
 }
 }
 else
 {
 iCurrentAlarmTime = Time::NullTTime();
 iAlarmOnOff = EFalse;
+iAbsoluteAlarmController->SetAbsoluteAlarmOff();
 }
 CleanupStack::PopAndDestroy( alarm );
 alarm = NULL;
 // Recurrence time has to be shown in the editor as local time
 TCalTime recurrenceTime;
 recurrenceTime.SetTimeUtcL( iCurrentRecurrenceUntil );
 TTime localRecurrenceTime = recurrenceTime.TimeLocalL();
-SetDateToEditor( *iRecurrenceUntilDate, localRecurrenceTime );
+SetDateToEditor(
+*iRecurrenceUntilDate,
+localRecurrenceTime );
 }
 }
 else
 {
 iRecurrenceValue = ERecurrenceNot;
 TTime recurUntil = RecurrenceUntilTime();
 if ( ERecurrenceUnknown != iRecurrenceValue &&
 recurUntil < startTime )
 {
 recurUntil = startTime + TTimeIntervalYears( KOne );
-iCurrentRecurrenceUntil = recurUntil;
+}
-}
+iCurrentRecurrenceUntil = recurUntil;
 }
 if ( iAlldayEvent && iAlarmOnOff )
 {
 // For alarm following cehcks and corrections are made:
 {
 if ( !iEntry->IsStoredL() )
 {
 // Setting alarm to default value if entry is not stored
 iAlarmOnOff = EFalse;
+iAbsoluteAlarmController->SetAbsoluteAlarmOff();
 }
 }
 iCurrentAlarmTime = alarmTime;
 }
 // End
 SetTimeToEditor( *iEndTime, endTime );
 SetDateToEditor( *iEndDate, endTime );
 // Alarm
-if(iAlarmTime)
+if( iAlarmOnOff && iAlarmTime )
 {
 SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );
 }
-if(iAlarmDate)
+if( iAlarmOnOff && iAlarmDate )
 {
 SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );
 }
 // if editing certain occurance of recurrent event series
 // the repeat until date is not available.
 if ( iRecurrenceUntilDate )
 {
 // Recurrence until
 SetDateToEditor( *iRecurrenceUntilDate, iCurrentRecurrenceUntil );
 }
+}
-}
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::ForceEndDateTime
 // ---------------------------------------------------------------------------
 //
 void CESMRMeetingTimeValidator::WriteStartAndEndTimeToEntryL(
 MESMRCalEntry& aEntry )
 {
 FUNC_LOG;
 CCalEntry& entry( aEntry.Entry() );
-const CCalEntry& originalEntry( aEntry.OriginalEntry() );
 TTime startTime = StartDateTime();
 TTime endTime = EndDateTime();
-TTime orgStartTime = originalEntry.StartTimeL().TimeLocalL();
+TTime orgStartTime = entry.StartTimeL().TimeLocalL();
-TTime orgEndTime   = originalEntry.EndTimeL().TimeLocalL();
+TTime orgEndTime   = entry.EndTimeL().TimeLocalL();
 if ( !aEntry.IsStoredL() || orgStartTime != startTime ||
 orgEndTime != endTime )
 {
 // End time has changed --> Store it to entry

branch	RCL_3
changeset 16	4ce476e64c59
parent 1	12c456ceeff2
child 24	b5fbb9b25d57