MCL/sf/app/commonemail: comparison meetingrequest/mrgui/src/cesmrtodotimevalidator.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".
 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;
 }
+aEditor.SetDate( aDate );
-if ( aEditor.IsVisible() )
-{
-aEditor.SetDate( aDate );
-}
 }
 /**
-* Returns the default alarm time for all day event
+* Returns the default alarm time for to-do
 * @param allday event start time
 * @return alarm time
 */
 TTime DefaultToDoAlarmL( TTime& aTodoDueDate )
 {
 // ---------------------------------------------------------------------------
 //
 inline CESMRTodoTimeValidator::CESMRTodoTimeValidator()
 :   iCurrentDueDate( Time::NullTTime() ),
 iCurrentAlarmTime( Time::NullTTime() ),
-iAlarmOnOff( EFalse )
+iAlarmOnOff( EFalse ),
+iInitialAlarmTime( Time::NullTTime() ),
+iInitialAlarmOnOff( EFalse ),
+iInitialDueDate( Time::NullTTime() )
 {
 FUNC_LOG;
 // Do nothing
 }
 SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );
 SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );
 error = MESMRFieldValidator::EErrorAlarmLaterThanStart;
 }
+			if ( alarm < start )
+				{
+				TTimeIntervalDays alarmBefore = start.DaysFrom(alarm);
+				if ( alarmBefore > KMaxAlarmTime )
+					{
+					error =  MESMRFieldValidator::EErrorAlarmTooMuchInPast;
+					}
+				}
 }
 }
 return error;
 }
 CCalEntry& entry( aEntry.Entry() );
 TCalTime dueDate = entry.EndTimeL();
 iCurrentDueDate = dueDate.TimeLocalL();
 SetDateToEditor( *iDueDate, iCurrentDueDate );
+iInitialDueDate = iDueDate->Date();
 TDateTime dueDt = iCurrentDueDate.DateTime();
 CCalAlarm* alarm = entry.AlarmL();
 CleanupStack::PushL( alarm );
 if  ( alarm )
 {
 iCurrentAlarmTime = iCurrentDueDate - alarm->TimeOffset();
 iAlarmOnOff = ETrue;
+iInitialAlarmOnOff = iAlarmOnOff;
 SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );
 SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );
+iInitialAlarmTime = iAlarmTime->Time();
+iInitialAlarmDate = iAlarmDate->Date();
 }
 CleanupStack::PopAndDestroy( alarm );
 alarm = NULL;
 if ( MESMRCalEntry::EESMRCalEntryTodo == aEntry.Type() )
 {
 PreValidateEditorContent();
 CCalEntry& entry( aEntry.Entry() );
-TTime toEditorDueDate = DueDateTimeL();
+// If entry has been modified, we will write new values to entry.
-TCalTime todoDueDate;
+// Otherwise entry will not be modified and thus saved
+// (ex. new entry and press only Done )
-// The default mode for To-do is EFloating,
+if( IsModifiedL( aEntry ) )
-// But some 3rd party application might have saved a different type
-// for one reason or another. In that case we are using
-// the existing value.
-if ( aEntry.IsStoredL() )
 {
-TCalTime::TTimeMode timeMode =
+TTime toEditorDueDate = DueDateTimeL();
-aEntry.Entry().StartTimeL().TimeMode();
+TCalTime todoDueDate;
-switch ( timeMode )
+// The default mode for To-do is EFloating,
+// But some 3rd party application might have saved a different type
+// for one reason or another. In that case we are using
+// the existing value.
+if ( aEntry.IsStoredL() )
 {
-case TCalTime::EFixedUtc:
+TCalTime::TTimeMode timeMode =
-	{
+aEntry.Entry().StartTimeL().TimeMode();
-todoDueDate.SetTimeUtcL( toEditorDueDate );
-break;
+switch ( timeMode )
-	}
+{
-case TCalTime::EFixedTimeZone:
+case TCalTime::EFixedUtc:
-	{
+{
-todoDueDate.SetTimeLocalL( toEditorDueDate );
+todoDueDate.SetTimeUtcL( toEditorDueDate );
 break;
-	}
+}
-case TCalTime::EFloating: // Fall through
+case TCalTime::EFixedTimeZone:
-default:
+{
-	{
+todoDueDate.SetTimeLocalL( toEditorDueDate );
-todoDueDate.SetTimeLocalFloatingL( toEditorDueDate );
+break;
-break;
+}
-	}
+case TCalTime::EFloating: // Fall through
+default:
+{
+todoDueDate.SetTimeLocalFloatingL( toEditorDueDate );
+break;
+}
+}
+}
+else
+{
+todoDueDate.SetTimeLocalFloatingL( toEditorDueDate );
+}
+entry.SetStartAndEndTimeL( todoDueDate, todoDueDate );
+if ( iAlarmOnOff )
+{
+TTimeIntervalMinutes diff;
+TTime alarm = AlarmDateTimeL();
+toEditorDueDate.MinutesFrom( alarm, diff );
+CCalAlarm* alarmObject = entry.AlarmL();
+if ( !alarmObject )
+{
+alarmObject = CCalAlarm::NewL();
+}
+CleanupStack::PushL( alarmObject );
+alarmObject->SetTimeOffset( diff );
+entry.SetAlarmL( alarmObject );
+CleanupStack::PopAndDestroy( alarmObject );
+alarmObject = NULL;
+}
+else
+{
+entry.SetAlarmL( NULL );
 }
 }
-else
-{
-todoDueDate.SetTimeLocalFloatingL( toEditorDueDate );
-}
-entry.SetStartAndEndTimeL( todoDueDate, todoDueDate );
-if ( iAlarmOnOff )
-{
-TTimeIntervalMinutes diff;
-TTime alarm = AlarmDateTimeL();
-toEditorDueDate.MinutesFrom( alarm, diff );
-CCalAlarm* alarmObject = entry.AlarmL();
-if ( !alarmObject )
-{
-alarmObject = CCalAlarm::NewL();
-}
-CleanupStack::PushL( alarmObject );
-alarmObject->SetTimeOffset( diff );
-entry.SetAlarmL( alarmObject );
-CleanupStack::PopAndDestroy( alarmObject );
-alarmObject = NULL;
-}
-else
-{
-entry.SetAlarmL( NULL );
-}
 }
 }
 // ---------------------------------------------------------------------------
 // CESMRTodoTimeValidator::SetStartTimeFieldL
 void CESMRTodoTimeValidator::SetEndDateFieldL(
 CEikDateEditor& aEndDate )
 {
 FUNC_LOG;
 iDueDate = &aEndDate;
+if ( Time::NullTTime() != iCurrentDueDate )
+{
+SetDateToEditor( *iDueDate, iCurrentDueDate );
+}
 }
 // ---------------------------------------------------------------------------
 // CESMRTodoTimeValidator::SetAlarmTimeFieldL
 // ---------------------------------------------------------------------------
 void CESMRTodoTimeValidator::SetAlarmTimeFieldL(
 CEikTimeEditor& aAlarmTime )
 {
 FUNC_LOG;
 iAlarmTime = &aAlarmTime;
+if ( iAlarmOnOff )
+{
+SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );
+}
 }
 // ---------------------------------------------------------------------------
 // CESMRTodoTimeValidator::SetAlarmDateFieldL
 // ---------------------------------------------------------------------------
 void CESMRTodoTimeValidator::SetAlarmDateFieldL(
 CEikDateEditor& aAlarmDate )
 {
 FUNC_LOG;
 iAlarmDate = &aAlarmDate;
+if ( iAlarmOnOff )
+{
+SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );
+}
 }
 // ---------------------------------------------------------------------------
 // CESMRTodoTimeValidator::SetRecurrenceUntilDateFieldL
 // ---------------------------------------------------------------------------
 //
 void CESMRTodoTimeValidator::SetRecurrenceUntilDateFieldL(
 CEikDateEditor& /*aRecurrenceUntil*/ )
+{
+FUNC_LOG;
+// No implementation for to-do
+}
+// ---------------------------------------------------------------------------
+// CESMRTodoTimeValidator::SetAbsoluteAlarmOnOffFieldL
+// ---------------------------------------------------------------------------
+//
+void CESMRTodoTimeValidator::SetAbsoluteAlarmOnOffFieldL(
+MMRAbsoluteAlarmController& /*aAbsoluteAlarmController*/ )
 {
 FUNC_LOG;
 // No implementation for to-do
 }
 void CESMRTodoTimeValidator::SetAlarmOnOffL(
 TBool aAlarmOn )
 {
 FUNC_LOG;
 iAlarmOnOff = aAlarmOn;
 if ( iAlarmOnOff )
 {
 if ( iCurrentAlarmTime == Time::NullTTime() ||
 iCurrentAlarmTime > iCurrentDueDate )
 {
 if ( iDueDate && iDueDate->IsVisible() )
 {
 iDueDate->PrepareForFocusLossL();
 }
-if ( iAlarmTime && iAlarmTime->IsVisible() )
+if ( iAlarmOnOff && iAlarmTime && iAlarmTime->IsVisible() )
 {
 iAlarmTime->PrepareForFocusLossL();
 }
-if ( iAlarmDate && iAlarmDate->IsVisible() )
+if ( iAlarmOnOff && iAlarmDate && iAlarmDate->IsVisible() )
 {
 iAlarmDate->PrepareForFocusLossL();
 }
 }
 iCurrentAlarmTime = alarm;
 }
 }
+// ---------------------------------------------------------------------------
+// CESMRTodoTimeValidator::IsModifiedL
+// ---------------------------------------------------------------------------
+//
+TBool CESMRTodoTimeValidator::IsModifiedL( MESMRCalEntry& aEntry )
+{
+// Checks if any of the editor fields have changed from the original /
+// initial values
+TBool isEdited( EFalse );
+TBool isSame = aEntry.Entry().CompareL( aEntry.OriginalEntry() );
+if( !isSame ||
+iInitialAlarmOnOff != iAlarmOnOff ||
+iDueDate->Date() != iInitialDueDate )
+{
+isEdited = ETrue;
+}
+// If alarm is on, we will check alarm time and date also for changes
+if( iAlarmOnOff )
+{
+if( iAlarmTime->Time() != iInitialAlarmTime ||
+iAlarmDate->Date() != iInitialAlarmDate )
+{
+isEdited = ETrue;
+}
+}
+return isEdited;
+}
 // EOF

branch	RCL_3
changeset 12	4ce476e64c59
parent 0	8466d47a6819