diff -r a3a1ae9acec6 -r da5135c61bad meetingrequest/mrgui/src/cesmrmeetingtimevalidator.cpp
--- a/meetingrequest/mrgui/src/cesmrmeetingtimevalidator.cpp	Mon Mar 15 12:39:10 2010 +0200
+++ b/meetingrequest/mrgui/src/cesmrmeetingtimevalidator.cpp	Wed Mar 31 21:08:33 2010 +0300
@@ -1,5 +1,5 @@
 /*
-* 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"
@@ -28,7 +28,9 @@
 #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
@@ -172,11 +174,8 @@
         {
         aTime = KMaxTTime;
         }
-
-    if ( aEditor.IsVisible() )
-        {
-        aEditor.SetTime( aTime );
-        }
+    
+    aEditor.SetTime( aTime );
     }
 
 /**
@@ -198,10 +197,28 @@
         aDate = KMaxTTime;
         }
 
-    if ( aEditor.IsVisible() )
+    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()   )
         {
-        aEditor.SetDate( aDate );
+        retValue = ETrue;
         }
+
+    return retValue;
     }
 
 } // namespace
@@ -309,8 +326,8 @@
             TDateTime endDt = endTime.DateTime();
 
             if ( startDt.Day() != endDt.Day() ||
-                    startDt.Month() != endDt.Month() ||
-                    startDt.Year() != endDt.Year() )
+                 startDt.Month() != endDt.Month() ||
+                 startDt.Year() != endDt.Year() )
                 {
                 error = MESMRFieldValidator::EErrorRecDifferetStartAndEnd;
                 }
@@ -338,14 +355,47 @@
                  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 )
             {
@@ -397,8 +447,7 @@
 
         TTime until;
         if ( iRecurrenceValue != ERecurrenceNot &&
-             iRecurrenceValue != ERecurrenceUnknown &&
-             iRecurrenceUntilDate && iRecurrenceUntilDate->IsVisible() )
+             iRecurrenceValue != ERecurrenceUnknown )
             {
             until = RecurrenceUntilTime();
 
@@ -417,6 +466,137 @@
     }
 
 // ---------------------------------------------------------------------------
+// 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
 // ---------------------------------------------------------------------------
 //
@@ -472,8 +652,9 @@
 
         ReadAlarmFromEntryL( entry );
         ReadRecurrenceFromEntryL( aEntry );
-
+        
         DrawEditorsDeferred();
+        SendFieldChangeEventL( EESMRFieldStartDate );
         }
     }
 // ---------------------------------------------------------------------------
@@ -566,6 +747,7 @@
             }
         }
 
+
     if ( ERecurrenceNot != iRecurrenceValue &&
          ERecurrenceUnknown != iRecurrenceValue )
         {
@@ -592,6 +774,11 @@
     {
     FUNC_LOG;
     iStartTime = &aStartTime;
+    
+    if ( Time::NullTTime() != iCurrentStartTime )
+        {
+        SetTimeToEditor( *iStartTime, iCurrentStartTime );
+        }
     }
 
 // ---------------------------------------------------------------------------
@@ -603,6 +790,11 @@
     {
     FUNC_LOG;
     iEndTime = &aEndTime;
+    
+    if ( Time::NullTTime() != iCurrentEndTime )
+        {
+        SetTimeToEditor( *iEndTime, iCurrentEndTime );
+        }    
     }
 
 // ---------------------------------------------------------------------------
@@ -614,6 +806,11 @@
     {
     FUNC_LOG;
     iStartDate = &aStartDate;
+    
+    if ( Time::NullTTime() != iCurrentStartTime )
+        {
+        SetDateToEditor( *iStartDate, iCurrentStartTime );
+        }    
     }
 
 // ---------------------------------------------------------------------------
@@ -625,6 +822,11 @@
     {
     FUNC_LOG;
     iEndDate = &aEndTime;
+    
+    if ( Time::NullTTime() != iCurrentEndTime )
+        {
+        SetDateToEditor( *iEndDate, iCurrentEndTime );
+        }    
     }
 
 // ---------------------------------------------------------------------------
@@ -635,7 +837,13 @@
         CEikTimeEditor& aAlarmTime )
     {
     FUNC_LOG;
+    
     iAlarmTime = &aAlarmTime;
+    
+    if ( iAlarmOnOff )
+        {
+        SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );
+        }
     }
 
 // ---------------------------------------------------------------------------
@@ -647,10 +855,15 @@
     {
     FUNC_LOG;
     iAlarmDate = &aAlarmDate;
+    
+    if ( iAlarmOnOff )
+        {
+        SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );
+        }
     }
 
 // ---------------------------------------------------------------------------
-// CESMRMeetingTimeValidator::StartTimeChangedL
+// CESMRMeetingTimeValidator::SetRecurrenceUntilDateFieldL
 // ---------------------------------------------------------------------------
 //
 void CESMRMeetingTimeValidator::SetRecurrenceUntilDateFieldL(
@@ -658,6 +871,23 @@
     {
     FUNC_LOG;
     iRecurrenceUntilDate = &aRecurrenceUntil;
+    
+    if ( Time::NullTTime() != iCurrentRecurrenceUntil )
+        {
+        SetDateToEditor( *iRecurrenceUntilDate, iCurrentRecurrenceUntil );       
+        }
+    
+    }
+
+// ---------------------------------------------------------------------------
+// CESMRMeetingTimeValidator::SetAbsoluteAlarmOnOffFieldL
+// ---------------------------------------------------------------------------
+//
+void CESMRMeetingTimeValidator::SetAbsoluteAlarmOnOffFieldL( 
+        MMRAbsoluteAlarmController& aAbsoluteAlarmController )
+    {
+    FUNC_LOG;
+    iAbsoluteAlarmController = &aAbsoluteAlarmController;
     }
 
 // ---------------------------------------------------------------------------
@@ -727,7 +957,6 @@
         }
 
     DrawEditorsDeferred();
-
     User::LeaveIfError( err );
     }
 
@@ -844,13 +1073,19 @@
     {
     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 );
@@ -971,7 +1206,6 @@
         }
     if ( iAlarmOnOff && iAlarmTime && iAlldayEvent && iAlarmTime->IsVisible() )
         {
-        TDateTime dt = iAlarmTime->Time().DateTime();
         iAlarmTime->PrepareForFocusLossL();
         }
     if ( iAlarmOnOff && iAlarmDate && iAlldayEvent && iAlarmDate->IsVisible() )
@@ -991,6 +1225,9 @@
 void CESMRMeetingTimeValidator::HandleStartTimeChangeL()
     {
     FUNC_LOG;
+    
+    TInt err( KErrNone );
+    
     TTime startTime = StartDateTime();
     TTime endTime   = EndDateTime();
     
@@ -1003,65 +1240,127 @@
                     iCurrentStartTime,
                     startTimeChange ) );
 
-    endTime += startTimeChange;
-    
-    if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )
+    if ( startTimeChange.Int() )
         {
-        MESMRMeetingRequestEntry* mrEntry = 
-                static_cast<MESMRMeetingRequestEntry*>( iEntry );
-        if ( mrEntry->IsRecurrentEventL() &&
-             MESMRCalEntry::EESMRThisOnly == mrEntry->RecurrenceModRule() )
+        endTime += startTimeChange;
+        
+        if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )
             {
-            TBool instanceAlreadyOnThisDay( 
-                       mrEntry->AnyInstanceOnDayL(startTime, endTime) );
-            
-            if ( instanceAlreadyOnThisDay )
+            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() )
                 {
-                // Restore previous time
-                SetTimeToEditor( *iStartTime, iCurrentStartTime );
-                SetDateToEditor( *iStartDate, iCurrentStartTime );
-                
-                User::Leave( KErrOverflow );
+                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;
+                }        
             }
         }
     
-    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;
-        }
+    DrawEditorsDeferred();
+    User::LeaveIfError( err );
     }
 
 // ---------------------------------------------------------------------------
@@ -1073,60 +1372,127 @@
     FUNC_LOG;
     TInt err( KErrNone );
     TTime startTime = StartDateTime();
-    TTime endTime   = EndDateTime();
-
-    if ( !iAlldayEvent && endTime < startTime )
-        {
-        if( ERecurrenceNot != iRecurrenceValue )
-            {
-            err = KErrArgument;
-            }
-        else
-            {
-            // End time is earlier than start time
-            // and this is not allday event.
-            endTime += TTimeIntervalDays( KOne );
-            }
-        }
+    TTime endTime = EndDateTime();
 
-    if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )
-        {
-        // Check that is modified entry 
-        MESMRMeetingRequestEntry* mrEntry = 
-                static_cast<MESMRMeetingRequestEntry*>( iEntry );
-        if ( mrEntry->IsRecurrentEventL() &&
-             MESMRCalEntry::EESMRThisOnly == mrEntry->RecurrenceModRule() )
+    // Check first if end time has even changed
+    TTimeIntervalMinutes endTimeChange;
+    User::LeaveIfError(
+            endTime.MinutesFrom(
+                    iCurrentEndTime,
+                    endTimeChange ) );    
+    
+    if ( endTimeChange.Int() )
+        {    
+        if ( !iAlldayEvent && endTime < startTime )
             {
-            TBool instanceAlreadyOnThisDay( 
-                       mrEntry->AnyInstanceOnDayL(startTime, endTime) );
-            
-            if ( instanceAlreadyOnThisDay )
+            if( ERecurrenceNot != iRecurrenceValue )
                 {
-                // Restore previous time
-                SetTimeToEditor( *iStartTime, iCurrentStartTime );
-                SetDateToEditor( *iStartDate, iCurrentStartTime );
-                
-                err = KErrOverflow;
+                err = KErrArgument;
+                }
+            else
+                {
+                // End time is earlier than start time
+                // and this is not allday event.
+                endTime += TTimeIntervalDays( KOne );
                 }
             }
-        }    
     
-    if ( KErrNone == err )
-        {
-        iCurrentStartTime = startTime;
-        iCurrentEndTime = endTime;
+        if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )
+            {
+            // Check that is modified entry 
+            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 )
+                        {
+                        // 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 ( !iAlldayEvent )
+            {
+            SetTimeToEditor( *iStartTime, iCurrentStartTime );
+            SetTimeToEditor( *iEndTime, iCurrentEndTime );
+            }
+    
+        SetDateToEditor( *iStartDate, iCurrentStartTime );
+        SetDateToEditor( *iEndDate, iCurrentEndTime );
+    
+        DrawEditorsDeferred();
+        User::LeaveIfError( err );
         }
-
-    if ( !iAlldayEvent )
-        {
-        SetTimeToEditor( *iStartTime, iCurrentStartTime );
-        SetTimeToEditor( *iEndTime, iCurrentEndTime );
-        }
-
-    SetDateToEditor( *iStartDate, iCurrentStartTime );
-    SetDateToEditor( *iEndDate, iCurrentEndTime );
-
-    User::LeaveIfError( err );
     }
 
 // ---------------------------------------------------------------------------
@@ -1215,10 +1581,8 @@
         TTime minTimeForRecurrenceEnd =
                 TimeForNextInstaceStartTime( iRecurrenceValue, start );
 
-        TDateTime a = iCurrentRecurrenceUntil.DateTime();
-        TDateTime b = minTimeForRecurrenceEnd.DateTime();
-
-        if ( iCurrentRecurrenceUntil < minTimeForRecurrenceEnd )
+        if ( Time::NullTTime() == iCurrentRecurrenceUntil || 
+             iCurrentRecurrenceUntil < minTimeForRecurrenceEnd )
             {
             iCurrentRecurrenceUntil = minTimeForRecurrenceEnd;
             }
@@ -1227,7 +1591,7 @@
         {
         iCurrentRecurrenceUntil = StartDateTime();
         }
-
+    
     if ( iRecurrenceUntilDate )
         {
         SetDateToEditor( *iRecurrenceUntilDate, iCurrentRecurrenceUntil );
@@ -1257,7 +1621,9 @@
 
     if ( iRecurrenceUntilDate )
         {
-        SetDateToEditor( *iRecurrenceUntilDate, iCurrentRecurrenceUntil );
+        SetDateToEditor( 
+                *iRecurrenceUntilDate, 
+                iCurrentRecurrenceUntil );
         }
 
     User::LeaveIfError( err );
@@ -1409,6 +1775,7 @@
         {
         iCurrentAlarmTime = Time::NullTTime();
         iAlarmOnOff = EFalse;
+        iAbsoluteAlarmController->SetAbsoluteAlarmOff();
         }
 
     CleanupStack::PopAndDestroy( alarm );
@@ -1443,7 +1810,9 @@
             recurrenceTime.SetTimeUtcL( iCurrentRecurrenceUntil );
             TTime localRecurrenceTime = recurrenceTime.TimeLocalL();
             
-            SetDateToEditor( *iRecurrenceUntilDate, localRecurrenceTime );
+            SetDateToEditor( 
+                    *iRecurrenceUntilDate, 
+                    localRecurrenceTime );
             }
         }
     else
@@ -1514,8 +1883,8 @@
              recurUntil < startTime )
             {
             recurUntil = startTime + TTimeIntervalYears( KOne );
-            iCurrentRecurrenceUntil = recurUntil;
             }
+        iCurrentRecurrenceUntil = recurUntil;
         }
 
     if ( iAlldayEvent && iAlarmOnOff )
@@ -1549,6 +1918,7 @@
                 {
                 // Setting alarm to default value if entry is not stored
                 iAlarmOnOff = EFalse;
+                iAbsoluteAlarmController->SetAbsoluteAlarmOff();
                 }
             }
 
@@ -1579,17 +1949,16 @@
     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 )
@@ -1597,10 +1966,8 @@
         // Recurrence until
         SetDateToEditor( *iRecurrenceUntilDate, iCurrentRecurrenceUntil );
         }
-
     }
 
-
 // ---------------------------------------------------------------------------
 // CESMRMeetingTimeValidator::ForceEndDateTime
 // ---------------------------------------------------------------------------
@@ -1674,13 +2041,12 @@
     {
     FUNC_LOG;
     CCalEntry& entry( aEntry.Entry() );
-    const CCalEntry& originalEntry( aEntry.OriginalEntry() );
 
     TTime startTime = StartDateTime();
     TTime endTime = EndDateTime();
 
-    TTime orgStartTime = originalEntry.StartTimeL().TimeLocalL();
-    TTime orgEndTime   = originalEntry.EndTimeL().TimeLocalL();
+    TTime orgStartTime = entry.StartTimeL().TimeLocalL();
+    TTime orgEndTime   = entry.EndTimeL().TimeLocalL();
 
     if ( !aEntry.IsStoredL() || orgStartTime != startTime ||
          orgEndTime != endTime )