1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  ESMR time and date sanity checks and saving

    15  *

    16 */

    17 

    18 

    19 #include "emailtrace.h"

    20 #include <eikmfne.h>

    21 #include <calentry.h>

    22 #include <calinstance.h>

    23 #include <calalarm.h>

    24 #include <calrrule.h>

    25 #include "cesmrmeetingtimevalidator.h"

    26 #include "cesmrglobalnote.h"

    27 #include "mesmrfieldstorage.h"

    28 #include "mesmrcalentry.h"

    29 #include "mesmrmeetingrequestentry.h"

    30 #include "mesmrfieldeventqueue.h"

    31 #include "mmrabsolutealarmcontroller.h"

    32 #include "cesmrgenericfieldevent.h"

    33 #include "cesmrrecurrenceinfohandler.h"

    34 

    35 // Unnamed namespace for local definitions

    36 namespace { // codescanner::namespace

    37 

    38 // Definition fom max possible time

    39 #define KMaxTTime (TTime(TDateTime(2100, EDecember, 31-2, 23, 59, 59, 999999)))

    40 

    41 // Definition fom min possible time

    42 #define KMinTTime (TTime(TDateTime(1900, EJanuary, 2-1, 0, 0, 0, 0)))

    43 

    44 // Definition for max alarm duration

    45 #define KMaxAlarmTime TTimeIntervalDays(31)

    46 

    47 // Definition for alarm time offset, when alarm is off

    48 const TInt KAlarmNotSet(-1);

    49 

    50 #ifdef _DEBUG

    51 

    52 // Literal for panics

    53 _LIT( KESMRMeetingTimeValidator, "ESMRMeetingTimeValidator" );

    54 

    55 /** Panic code definitions */

    56 enum TKESMRMeetingTimeValidator

    57     {

    58     /** Start time field not set */

    59     EESMRMeetingTimeValidatorNullStartTime,

    60     /** Stop time field not set */

    61     EESMRMeetingTimeValidatorNullStopTime,

    62     /** Start date field not set */

    63     EESMRMeetingTimeValidatorNullStartDate,

    64     /** Stop date field not set */

    65     EESMRMeetingTimeValidatorNullStopDate,

    66     /** Stop time field not set */

    67     EESMRMeetingTimeValidatorStartLaterThanEnd,

    68     /** Invalid date field id */

    69     EESMRMeetingTimeValidatorInvalidDateField

    70     };

    71 

    72 /**

    73  * Raises system panic.

    74  * @param aPanic Panic code

    75  * @see TESMRRecurrentEditValidatorPanic

    76  */

    77 void Panic( TKESMRMeetingTimeValidator aPanic )

    78     {

    79     User::Panic( KESMRMeetingTimeValidator, aPanic );

    80     }

    81 

    82 #endif // _DEBUG

    83 

    84 const TInt KZero( 0 );

    85 const TInt KOne( 1 );

    86 const TInt KDaysInWeek( 7 );

    87 const TInt KDaysInFortnight( 14 );

    88 const TInt KNoon(12);

    89 

    90 /**

    91  * Calculates time for next instance for recurrent event.

    92  * @param aRecurrenceValue Defines the used recurrence.

    93  * @param aPrevInstanceStartTime Start time of the previous instance.

    94  */

    95 TTime TimeForNextInstaceStartTime(

    96         TESMRRecurrenceValue aRecurrenceValue,

    97         TTime& aPrevInstanceStartTime )

    98     {

    99     TTime nextStartTime = aPrevInstanceStartTime;

   100 

   101     switch ( aRecurrenceValue )

   102         {

   103         case ERecurrenceDaily:

   104             {

   105             nextStartTime += TTimeIntervalDays( KOne );

   106             }

   107             break;

   108 

   109         case ERecurrenceWeekly:

   110             {

   111             nextStartTime += TTimeIntervalDays( KDaysInWeek );

   112             }

   113             break;

   114 

   115 

   116         case ERecurrenceEverySecondWeek:

   117             {

   118             nextStartTime += TTimeIntervalDays( KDaysInFortnight );

   119             }

   120             break;

   121 

   122         case ERecurrenceMonthly:

   123             {

   124             nextStartTime += TTimeIntervalMonths( KOne );

   125             }

   126             break;

   127 

   128         case ERecurrenceYearly:

   129             {

   130             nextStartTime += TTimeIntervalYears( KOne );

   131             }

   132             break;

   133 

   134         default:

   135             nextStartTime = aPrevInstanceStartTime;

   136             break;

   137         }

   138 

   139     return nextStartTime;

   140     }

   141 

   142 /**

   143  * Returns the default alarm time for all day event

   144  * @param allday event start time

   145  * @return alarm time

   146  */

   147 TTime DefaultAlldayEventAlarmTime( TTime& aMeetingStartTime )

   148     {

   149     TTime defaultAlarmTime = aMeetingStartTime - TTimeIntervalHours(KNoon);

   150 

   151     if ( defaultAlarmTime < KMinTTime )

   152         {

   153         defaultAlarmTime = KMinTTime;

   154         }

   155     return defaultAlarmTime;

   156     }

   157 

   158 

   159 /**

   160  * Sets time to editor. Time is checked and adjusted

   161  * between min and max before setting

   162  * @param aEditor Reference to time editor

   163  * @param aTime On return contains the set time.

   164  */

   165 void SetTimeToEditor(

   166         CEikTimeEditor& aEditor,

   167         TTime& aTime )

   168     {

   169     if ( aTime < KMinTTime )

   170         {

   171         aTime = KMinTTime;

   172         }

   173     else if ( aTime > KMaxTTime )

   174         {

   175         aTime = KMaxTTime;

   176         }

   177     

   178     aEditor.SetTime( aTime );

   179     }

   180 

   181 /**

   182  * Sets date to editor. Date is checked and adjusted

   183  * between min and max before setting

   184  * @param aEditor Reference to time editor

   185  * @param aDate On return contains the set date.

   186  */

   187 void SetDateToEditor(

   188         CEikDateEditor& aEditor,

   189         TTime& aDate )

   190     {

   191     if ( aDate < KMinTTime )

   192         {

   193         aDate = KMinTTime;

   194         }

   195     else if ( aDate > KMaxTTime )

   196         {

   197         aDate = KMaxTTime;

   198         }

   199 

   200     aEditor.SetDate( aDate );

   201     }

   202 

   203 /**

   204  * Compares two times and returns ETrue if they have same date components

   205  * @param aLhs Left hand side component

   206  * @param aRhs Right hand side component

   207  */

   208 TBool IsSameDay(

   209         const TDateTime& aLhs,

   210         const TDateTime& aRhs )

   211     {

   212     TBool retValue(EFalse);

   213 

   214     if ( aLhs.Day() == aRhs.Day() &&

   215          aLhs.Month() == aRhs.Month() &&

   216          aLhs.Year() == aRhs.Year()   )

   217         {

   218         retValue = ETrue;

   219         }

   220 

   221     return retValue;

   222     }

   223 

   224 } // namespace

   225 

   226 // ======== MEMBER FUNCTIONS ========

   227 

   228 // ---------------------------------------------------------------------------

   229 // CESMRMeetingTimeValidator::CESMRMeetingTimeValidator

   230 // ---------------------------------------------------------------------------

   231 //

   232 inline CESMRMeetingTimeValidator::CESMRMeetingTimeValidator()

   233 :   iRecurrenceValue( ERecurrenceNot ),

   234     iCurrentStartTime( Time::NullTTime() ),

   235     iCurrentEndTime( Time::NullTTime() ),

   236     iCurrentAlarmTime( Time::NullTTime() ),

   237     iCurrentRecurrenceUntil( Time::NullTTime() ),

   238     iStartTimeBeforeAlldayEvent( Time::NullTTime() ),

   239     iEndTimeBeforeAlldayEvent( Time::NullTTime() ),

   240     iAlldayEvent( EFalse ),

   241     iAlarmOnOff( EFalse ),

   242     iComparativeStartTime( Time::NullTTime().DateTime() )

   243     {

   244     FUNC_LOG;

   245     // Do nothing

   246     }

   247 

   248 // ---------------------------------------------------------------------------

   249 // CESMRMeetingTimeValidator::~CESMRMeetingTimeValidator

   250 // ---------------------------------------------------------------------------

   251 //

   252 CESMRMeetingTimeValidator::~CESMRMeetingTimeValidator( )

   253     {

   254     FUNC_LOG;

   255     // Do nothing

   256     }

   257 

   258 // ---------------------------------------------------------------------------

   259 // CESMRMeetingTimeValidator::NewL

   260 // ---------------------------------------------------------------------------

   261 //

   262 CESMRMeetingTimeValidator* CESMRMeetingTimeValidator::NewL( )

   263     {

   264     FUNC_LOG;

   265     CESMRMeetingTimeValidator* self = new (ELeave) CESMRMeetingTimeValidator();

   266     return self;

   267     }

   268 

   269 // ---------------------------------------------------------------------------

   270 // CESMRMeetingTimeValidator::ValidateL

   271 // ---------------------------------------------------------------------------

   272 //

   273 MESMRFieldValidator::TESMRFieldValidatorError

   274         CESMRMeetingTimeValidator::ValidateL(

   275                     TBool aCorrectAutomatically )

   276     {

   277     FUNC_LOG;

   278     MESMRFieldValidator::TESMRFieldValidatorError KErrorNone(

   279             MESMRFieldValidator::EErrorNone );

   280 

   281     MESMRFieldValidator::TESMRFieldValidatorError error(

   282             MESMRFieldValidator::EErrorNone );

   283 

   284     if( aCorrectAutomatically )

   285         {

   286         ForceValuesL();

   287         }

   288     else

   289         {

   290         TTime startTime = StartDateTime();

   291         TTime endTime = EndDateTime();

   292 

   293         // In recurrent events if user has changed the start date and

   294         // presses Save or Done, we have to force the end date to same

   295         // value as start date and modify the recurrence until according

   296         // to the new start time value

   297         if ( ERecurrenceNot != iRecurrenceValue &&

   298                 ( startTime.DateTime().Day() != endTime.DateTime().Day() ||

   299                 startTime.DateTime().Month() != endTime.DateTime().Month() ||

   300                 startTime.DateTime().Year() != endTime.DateTime().Year() ) )

   301             {

   302             endTime = ForceEndDateTime();

   303 

   304             SetTimeToEditor( *iEndTime, endTime );

   305             SetDateToEditor( *iEndDate, endTime );

   306 

   307             // We have to also adjust the recurrence until time

   308             // according to the new start time

   309             TTime newUntil = ForceRecurrenceUntilTime();

   310 

   311             SetDateToEditor( *iRecurrenceUntilDate, newUntil );

   312             }

   313 

   314         TTime currentAlarmTime = startTime - iCurrentAlarmTimeOffset;

   315         TTime currentTime;

   316         currentTime.HomeTime();

   317 

   318         if ( endTime < startTime )

   319             {

   320             error = MESMRFieldValidator::EErrorEndEarlierThanStart;

   321             }

   322 

   323         if ( KErrorNone == error && ERecurrenceNot != iRecurrenceValue )

   324             {

   325             TDateTime startDt = startTime.DateTime();

   326             TDateTime endDt = endTime.DateTime();

   327 

   328             if ( startDt.Day() != endDt.Day() ||

   329                  startDt.Month() != endDt.Month() ||

   330                  startDt.Year() != endDt.Year() )

   331                 {

   332                 error = MESMRFieldValidator::EErrorRecDifferetStartAndEnd;

   333                 }

   334 

   335             if ( KErrorNone == error &&

   336                  ERecurrenceNot != iRecurrenceValue &&

   337                  iRecurrenceUntilDate && iRecurrenceUntilDate->IsVisible() )

   338                 {

   339                 TTime recurUntil = RecurrenceUntilTime();

   340                 if ( ERecurrenceUnknown != iRecurrenceValue &&

   341                      recurUntil < startTime )

   342                     {

   343                     error = MESMRFieldValidator::EErrorRecUntilEarlierThanStart;

   344                     }

   345                 }

   346             }

   347 

   348         if (  KErrorNone == error &&  

   349               MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )

   350             {

   351             // Check that is modified entry 

   352             MESMRMeetingRequestEntry* mrEntry = 

   353                     static_cast<MESMRMeetingRequestEntry*>( iEntry );

   354             if ( mrEntry->IsRecurrentEventL() &&

   355                  MESMRCalEntry::EESMRThisOnly == mrEntry->RecurrenceModRule() )

   356                 {

   357                 TBool instanceAlreadyOnThisDay( 

   358                            mrEntry->AnyInstancesBetweenTimePeriodL(

   359                         		   startTime, 

   360                         		   endTime ) );

   361                 

   362                 if ( instanceAlreadyOnThisDay )

   363                     {

   364                     error = MESMRFieldValidator::EErrorRescheduleInstance;

   365                     }

   366                 }

   367             }

   368         

   369         if (  KErrorNone == error &&  

   370               MESMRCalEntry::EESMRCalEntryMeeting == iEntry->Type() )

   371             {

   372             // Check that is modified entry 

   373             if ( iEntry->IsRecurrentEventL() &&

   374                  MESMRCalEntry::EESMRThisOnly == iEntry->RecurrenceModRule() )

   375                 {

   376                 TBool instanceAlreadyOnThisDay( 

   377                            iEntry->AnyInstancesBetweenTimePeriodL(

   378                         		   startTime, 

   379                         		   endTime ) );

   380                 

   381                 if ( instanceAlreadyOnThisDay )

   382                     {

   383                     error = MESMRFieldValidator::EErrorRescheduleInstance;

   384                     }

   385                 }

   386             }  

   387         

   388         if (  KErrorNone == error &&  

   389               ( MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() || 

   390                 MESMRCalEntry::EESMRCalEntryMeeting == iEntry->Type() ) )

   391             {

   392             // Check that is modified entry 

   393             if ( iEntry->IsRecurrentEventL() &&

   394                  MESMRCalEntry::EESMRThisOnly == iEntry->RecurrenceModRule() )

   395                 {

   396                 error = ValidateEditedInstanceTimeL();

   397                 }

   398             }

   399         

   400         if ( KErrorNone == error && iAlldayEvent && iAlarmOnOff )

   401             {

   402             TTime alarmTime = AlarmDateTime();

   403             if ( alarmTime > startTime )

   404                 {

   405                 SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );

   406                 SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );

   407 

   408                 error = MESMRFieldValidator::EErrorAlarmLaterThanStart;

   409                 }

   410 

   411             TTime currentTime;

   412             currentTime.HomeTime();

   413             if ( KErrorNone == error && alarmTime < currentTime )

   414                 {

   415                 error = MESMRFieldValidator::EErrorAlarmInPast;

   416                 }

   417             if ( KErrorNone == error && alarmTime < startTime )

   418                 {

   419                 TTimeIntervalDays alarmBefore = startTime.DaysFrom(alarmTime);

   420                 if ( alarmBefore > KMaxAlarmTime )

   421                     {

   422                     error =  MESMRFieldValidator::EErrorAlarmTooMuchInPast;

   423                     }

   424                 }

   425             }

   426 

   427         MESMRCalEntry::TESMRRecurrenceModifyingRule rule =

   428             MESMRCalEntry::EESMRThisOnly;

   429 

   430         // Checking if entry is recurrent

   431         if ( iEntry->IsRecurrentEventL())

   432             {

   433             // Getting the recurrence information

   434             rule = iEntry->RecurrenceModRule();

   435             }

   436 

   437         // Showing error note if alarm in past, when

   438         // entry has no recurrence

   439         if ( KErrorNone == error &&

   440              currentAlarmTime < currentTime &&

   441              !iAlldayEvent &&

   442              iCurrentAlarmTimeOffset.Int() != KAlarmNotSet &&

   443              iRecurrenceValue == ERecurrenceNot )

   444             {

   445             error = MESMRFieldValidator::EErrorRelativeAlarmInPast;

   446             }

   447 

   448         TTime until;

   449         if ( iRecurrenceValue != ERecurrenceNot &&

   450              iRecurrenceValue != ERecurrenceUnknown )

   451             {

   452             until = RecurrenceUntilTime();

   453 

   454             // Showing error note if is alarm in past, 

   455             // when entry has recurrence

   456             if ( KErrorNone == error &&

   457                  iCurrentAlarmTimeOffset.Int() != KAlarmNotSet &&

   458                  until < currentTime &&

   459                  rule != MESMRCalEntry::EESMRAllInSeries )

   460                 {

   461                 error = MESMRFieldValidator::EErrorRelativeAlarmInPast;

   462                 }

   463             }

   464         }

   465     return error;

   466     }

   467 

   468 // ---------------------------------------------------------------------------

   469 // CESMRMeetingTimeValidator::ValidateEditedInstanceTimeL

   470 // ---------------------------------------------------------------------------

   471 //

   472 MESMRFieldValidator::TESMRFieldValidatorError CESMRMeetingTimeValidator::ValidateEditedInstanceTimeL()

   473     { 

   474     CESMRRecurrenceInfoHandler* recurrenceHandler =

   475                 CESMRRecurrenceInfoHandler::NewLC( iEntry->Entry(), &iEntry->GetDBMgr() );

   476     TCalTime preStartTime;

   477     TCalTime preEndTime;

   478     TCalTime nextStartTime;

   479     TCalTime nextEndTime;

   480 

   481     CCalInstance* instance = iEntry->InstanceL();

   482     CleanupStack::PushL( instance );

   483     TTime instanceDateTime = instance->StartTimeL().TimeLocalL();

   484     CleanupStack::PopAndDestroy( instance );

   485 

   486     recurrenceHandler->GetPreviousInstanceTimeL( preStartTime, preEndTime, instanceDateTime );

   487     recurrenceHandler->GetNextInstanceTimeL( nextStartTime, nextEndTime, instanceDateTime );

   488 

   489     CleanupStack::PopAndDestroy( recurrenceHandler );

   490 

   491     const TTime editedStartDateTime( StartDateTime() );

   492     const TTime editedEndDateTime( EndDateTime() );  

   493 

   494     if( preStartTime.TimeLocalL() != Time::NullTTime() )

   495         {

   496         // Does the exception end on/after prevEnd?

   497         if( editedStartDateTime < preEndTime.TimeLocalL() )

   498             {

   499             // Does the exception start after prevStart?

   500             if( editedStartDateTime > preStartTime.TimeLocalL() )

   501                 {

   502                 return EErrorInstanceOverlapsExistingOne;

   503                 }

   504             else

   505                 {

   506                 // Does the exception finish after prevStart?

   507                 if( editedEndDateTime > preStartTime.TimeLocalL() )

   508                     {

   509                     return EErrorInstanceOverlapsExistingOne;

   510                     }

   511                 else

   512                     {

   513                     return EErrorInstanceOutOfSequence;

   514                     }

   515                 }

   516             }

   517 

   518         // Does the exception start on the same day as prevStart?

   519         if( IsSameDay( StartDateTime(), preStartTime.TimeLocalL().DateTime() ) )

   520             {

   521             return EErrorInstanceAlreadyExistsOnThisDay;

   522             }

   523         }

   524 

   525 

   526     if( nextStartTime.TimeLocalL() != Time::NullTTime() )

   527         {

   528         // Does the exception finish on/before nextStart?

   529         if( editedEndDateTime > nextStartTime.TimeLocalL() )

   530             {

   531             // Does the exception finish before nextFinish?

   532             if( editedEndDateTime < nextEndTime.TimeLocalL() )

   533                 {

   534                 return EErrorInstanceOverlapsExistingOne;

   535                 }

   536             else

   537                 {

   538                 // Does the exception start before nextFinish?

   539                 if( editedStartDateTime < nextEndTime.TimeLocalL() )

   540                     {

   541                     return EErrorInstanceOverlapsExistingOne;

   542                     }

   543                 else

   544                     {

   545                     return EErrorInstanceOutOfSequence;

   546                     }

   547                 }

   548             }

   549 

   550         // Does the exception start on the same day as nextStart?

   551         if( IsSameDay( StartDateTime(), nextStartTime.TimeLocalL().DateTime() ) )

   552             {

   553             return EErrorInstanceAlreadyExistsOnThisDay;

   554             }

   555         }

   556 

   557 

   558     // Does the series have any rdates

   559     RArray<TCalTime> rDateArray;

   560     CleanupClosePushL( rDateArray );

   561     iEntry->Entry().GetRDatesL( rDateArray );

   562     TInt rDateCount = rDateArray.Count();

   563 

   564     if ( rDateCount > 0 )

   565         {

   566         // If the series has rdates, check that the exception

   567         // does not overlap or start on the same day

   568         TTimeIntervalMinutes duration;

   569         editedStartDateTime.MinutesFrom( editedEndDateTime, duration );

   570 

   571         for ( TInt index = 0; index < rDateCount; index++ )

   572             {

   573             const TTime& rDate = rDateArray[ index ].TimeLocalL();

   574 

   575             if ( !IsSameDay( iEntry->Entry().StartTimeL().TimeLocalL().DateTime(), rDate.DateTime() ) )

   576                 {

   577                 // Does the exception start or end on the same day as a rdate.

   578                 if ( IsSameDay( StartDateTime(), rDate.DateTime() ) )

   579                     {

   580                     CleanupStack::PopAndDestroy(); // rDateArray

   581                     return EErrorInstanceAlreadyExistsOnThisDay;

   582                     }

   583 

   584                 // Does the exception overlap an rdate?

   585                 TTime rDateEnd = rDate + duration;

   586                 if ( editedEndDateTime > rDateEnd && editedStartDateTime < rDate )

   587                     {

   588                     CleanupStack::PopAndDestroy(); // rDateArray

   589                     return EErrorInstanceOverlapsExistingOne;

   590                     }

   591                 }

   592             }

   593         }

   594 

   595     CleanupStack::PopAndDestroy(); // rDateArray

   596     return EErrorNone;

   597     }

   598 

   599 // ---------------------------------------------------------------------------

   600 // CESMRMeetingTimeValidator::ReadValuesFromEntryL

   601 // ---------------------------------------------------------------------------

   602 //

   603 void CESMRMeetingTimeValidator::ReadValuesFromEntryL(

   604         MESMRCalEntry& aEntry )

   605     {

   606     FUNC_LOG;

   607     MESMRCalEntry::TESMRCalEntryType entryType( aEntry.Type() );

   608 

   609     if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == entryType ||

   610          MESMRCalEntry::EESMRCalEntryMeeting == entryType   )

   611         {

   612         // Meeting or meeting request

   613         __ASSERT_DEBUG(

   614                 iStartTime,

   615                 Panic(EESMRMeetingTimeValidatorNullStartTime) );

   616 

   617         __ASSERT_DEBUG(

   618                 iEndTime,

   619                 Panic(EESMRMeetingTimeValidatorNullStopTime) );

   620 

   621         __ASSERT_DEBUG(

   622                 iStartDate,

   623                 Panic(EESMRMeetingTimeValidatorNullStartTime) );

   624 

   625         __ASSERT_DEBUG(

   626                 iEndDate,

   627                 Panic(EESMRMeetingTimeValidatorNullStopTime) );

   628 

   629         iEntry = &aEntry;

   630         CCalEntry& entry( aEntry.Entry() );

   631 

   632         iCurrentStartTime = entry.StartTimeL().TimeLocalL();

   633         iCurrentEndTime   = entry.EndTimeL().TimeLocalL();

   634 

   635         //Comparative start time required for comparisons in editor

   636         //recurrence handling

   637         iComparativeStartTime = iCurrentStartTime.DateTime();

   638 

   639         if ( aEntry.IsAllDayEventL() )

   640             {

   641             iCurrentEndTime -= TTimeIntervalDays( KOne );

   642             }

   643 

   644         TTime start = iCurrentStartTime;

   645         TTime end = iCurrentEndTime;

   646 

   647         SetTimeToEditor( *iStartTime, start );

   648         SetDateToEditor( *iStartDate, start );

   649 

   650         SetTimeToEditor( *iEndTime, end );

   651         SetDateToEditor( *iEndDate, end );

   652 

   653         ReadAlarmFromEntryL( entry );

   654         ReadRecurrenceFromEntryL( aEntry );

   655         

   656         DrawEditorsDeferred();

   657         SendFieldChangeEventL( EESMRFieldStartDate );

   658         }

   659     }

   660 // ---------------------------------------------------------------------------

   661 // CESMRMeetingTimeValidator::StoreValuesToEntryL

   662 // ---------------------------------------------------------------------------

   663 //

   664 void CESMRMeetingTimeValidator::StoreValuesToEntryL(

   665         MESMRCalEntry& aEntry )

   666     {

   667     FUNC_LOG;

   668     CCalEntry& entry( aEntry.Entry() );

   669 

   670     // Before writing start and end time to enty, let's

   671     // check is currently edited entry exception for series

   672     // If entry is an exception and start time is set after

   673     // repeat until date; the calinterim API will delete

   674     // the recurrence rules from entry, so the

   675     // solution to avoid this is to move the repeat until date

   676     // to match the new start and end time for this exception entry.

   677     if ( ERecurrenceNot == iRecurrenceValue &&

   678          aEntry.IsRecurrentEventL() &&

   679          MESMRCalEntry::EESMRThisOnly == aEntry.RecurrenceModRule() )

   680         {

   681         TCalRRule originalRRule;

   682         if ( iEntry->Entry().GetRRuleL( originalRRule ) )

   683             {

   684             TTime localUntilTime = originalRRule.Until().TimeLocalL();

   685             TTime endTime = EndDateTime();

   686             TDateTime datetimeendtime = endTime.DateTime();

   687             TDateTime datetimelocalUntil = localUntilTime.DateTime();

   688 

   689             if ( endTime > localUntilTime )

   690                 {

   691                 TCalRRule rRule;

   692                 rRule.SetDtStart( originalRRule.DtStart() );

   693                 rRule.SetType( originalRRule.Type() );

   694 

   695                 TCalTime newUntil;

   696                 newUntil.SetTimeLocalL( endTime );

   697                 rRule.SetUntil( newUntil );

   698                 rRule.SetInterval( originalRRule.Interval() );

   699                 iEntry->Entry().SetRRuleL( rRule );

   700                 }

   701             }

   702         }

   703     else if ( aEntry.IsRecurrentEventL() &&

   704               MESMRCalEntry::EESMRAllInSeries == aEntry.RecurrenceModRule() )

   705         {

   706         TTime orgStartTime = iEntry->Entry().StartTimeL().TimeLocalL();

   707         TTime orgEndTime = iEntry->Entry().EndTimeL().TimeLocalL();

   708         

   709         if ( orgStartTime != StartDateTime() || 

   710              orgEndTime != EndDateTime() )

   711             {

   712             // We are editing the series --> We need to clear the recurrence from the entry

   713             // When changing start or end time --> Exceptions needs to be cleared from the series

   714             // It is set later in this method.

   715             aEntry.SetRecurrenceL( ERecurrenceNot, Time::NullTTime() );

   716             }

   717         }

   718 

   719     WriteStartAndEndTimeToEntryL( aEntry );

   720 

   721     if ( iAlldayEvent )

   722         {

   723         TTime startTime = StartDateTime();

   724         TTime endTime = EndDateTime();

   725 

   726         // For all day event end time is adjusted 24 hours 

   727         // forward so that it ends correctly

   728         aEntry.SetAllDayEventL( startTime, endTime );

   729 

   730         if ( iAlarmOnOff )

   731             {

   732             TTime alarmTime = AlarmDateTime();

   733             TTimeIntervalMinutes alarmDiff;

   734             startTime.MinutesFrom( alarmTime, alarmDiff );

   735 

   736             CCalAlarm* alarm = CCalAlarm::NewL();

   737             CleanupStack::PushL( alarm );

   738             alarm->SetTimeOffset( alarmDiff );

   739 

   740             entry.SetAlarmL( alarm );

   741             CleanupStack::PopAndDestroy( alarm );

   742             alarm = NULL;

   743             }

   744         else

   745             {

   746             entry.SetAlarmL( NULL );

   747             }

   748         }

   749 

   750 

   751     if ( ERecurrenceNot != iRecurrenceValue &&

   752          ERecurrenceUnknown != iRecurrenceValue )

   753         {

   754         aEntry.SetRecurrenceL(

   755                 iRecurrenceValue,

   756                 RecurrenceUntilTime() );

   757         }

   758     else if ( ERecurrenceNot == iRecurrenceValue &&

   759               aEntry.IsRecurrentEventL() &&

   760               MESMRCalEntry::EESMRAllInSeries == aEntry.RecurrenceModRule() )

   761         {

   762         aEntry.SetRecurrenceL(

   763                 iRecurrenceValue,

   764                 Time::NullTTime() );

   765         }

   766     }

   767 

   768 // ---------------------------------------------------------------------------

   769 // CESMRMeetingTimeValidator::SetStartTimeFieldL

   770 // ---------------------------------------------------------------------------

   771 //

   772 void CESMRMeetingTimeValidator::SetStartTimeFieldL(

   773         CEikTimeEditor& aStartTime )

   774     {

   775     FUNC_LOG;

   776     iStartTime = &aStartTime;

   777     

   778     if ( Time::NullTTime() != iCurrentStartTime )

   779         {

   780         SetTimeToEditor( *iStartTime, iCurrentStartTime );

   781         }

   782     }

   783 

   784 // ---------------------------------------------------------------------------

   785 // CESMRMeetingTimeValidator::SetEndTimeFieldL

   786 // ---------------------------------------------------------------------------

   787 //

   788 void CESMRMeetingTimeValidator::SetEndTimeFieldL(

   789         CEikTimeEditor& aEndTime )

   790     {

   791     FUNC_LOG;

   792     iEndTime = &aEndTime;

   793     

   794     if ( Time::NullTTime() != iCurrentEndTime )

   795         {

   796         SetTimeToEditor( *iEndTime, iCurrentEndTime );

   797         }    

   798     }

   799 

   800 // ---------------------------------------------------------------------------

   801 // CESMRMeetingTimeValidator::SetStartDateFieldL

   802 // ---------------------------------------------------------------------------

   803 //

   804 void CESMRMeetingTimeValidator::SetStartDateFieldL(

   805         CEikDateEditor& aStartDate )

   806     {

   807     FUNC_LOG;

   808     iStartDate = &aStartDate;

   809     

   810     if ( Time::NullTTime() != iCurrentStartTime )

   811         {

   812         SetDateToEditor( *iStartDate, iCurrentStartTime );

   813         }    

   814     }

   815 

   816 // ---------------------------------------------------------------------------

   817 // CESMRMeetingTimeValidator::SetEndDateFieldL

   818 // ---------------------------------------------------------------------------

   819 //

   820 void CESMRMeetingTimeValidator::SetEndDateFieldL(

   821         CEikDateEditor& aEndTime )

   822     {

   823     FUNC_LOG;

   824     iEndDate = &aEndTime;

   825     

   826     if ( Time::NullTTime() != iCurrentEndTime )

   827         {

   828         SetDateToEditor( *iEndDate, iCurrentEndTime );

   829         }    

   830     }

   831 

   832 // ---------------------------------------------------------------------------

   833 // CESMRMeetingTimeValidator::SetAlarmTimeFieldL

   834 // ---------------------------------------------------------------------------

   835 //

   836 void CESMRMeetingTimeValidator::SetAlarmTimeFieldL(

   837         CEikTimeEditor& aAlarmTime )

   838     {

   839     FUNC_LOG;

   840     

   841     iAlarmTime = &aAlarmTime;

   842     

   843     if ( iAlarmOnOff )

   844         {

   845         SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );

   846         }

   847     }

   848 

   849 // ---------------------------------------------------------------------------

   850 // CESMRMeetingTimeValidator::SetAlarmDateFieldL

   851 // ---------------------------------------------------------------------------

   852 //

   853 void CESMRMeetingTimeValidator::SetAlarmDateFieldL(

   854         CEikDateEditor& aAlarmDate )

   855     {

   856     FUNC_LOG;

   857     iAlarmDate = &aAlarmDate;

   858     

   859     if ( iAlarmOnOff )

   860         {

   861         SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );

   862         }

   863     }

   864 

   865 // ---------------------------------------------------------------------------

   866 // CESMRMeetingTimeValidator::SetRecurrenceUntilDateFieldL

   867 // ---------------------------------------------------------------------------

   868 //

   869 void CESMRMeetingTimeValidator::SetRecurrenceUntilDateFieldL(

   870         CEikDateEditor& aRecurrenceUntil )

   871     {

   872     FUNC_LOG;

   873     iRecurrenceUntilDate = &aRecurrenceUntil;

   874     

   875     if ( Time::NullTTime() != iCurrentRecurrenceUntil )

   876         {

   877         SetDateToEditor( *iRecurrenceUntilDate, iCurrentRecurrenceUntil );       

   878         }

   879     

   880     }

   881 

   882 // ---------------------------------------------------------------------------

   883 // CESMRMeetingTimeValidator::SetAbsoluteAlarmOnOffFieldL

   884 // ---------------------------------------------------------------------------

   885 //

   886 void CESMRMeetingTimeValidator::SetAbsoluteAlarmOnOffFieldL( 

   887         MMRAbsoluteAlarmController& aAbsoluteAlarmController )

   888     {

   889     FUNC_LOG;

   890     iAbsoluteAlarmController = &aAbsoluteAlarmController;

   891     }

   892 

   893 // ---------------------------------------------------------------------------

   894 // CESMRMeetingTimeValidator::StartTimeChangedL

   895 // ---------------------------------------------------------------------------

   896 //

   897 void CESMRMeetingTimeValidator::StartTimeChangedL()

   898     {

   899     FUNC_LOG;

   900     StartDateChandedL();

   901     }

   902 

   903 // ---------------------------------------------------------------------------

   904 // CESMRMeetingTimeValidator::EndTimeChangedL

   905 // ---------------------------------------------------------------------------

   906 //

   907 void CESMRMeetingTimeValidator::EndTimeChangedL()

   908     {

   909     FUNC_LOG;

   910     PreValidateEditorContent();

   911     HandleEndTimeChangeL();

   912     DrawEditorsDeferred();

   913     }

   914 

   915 // ---------------------------------------------------------------------------

   916 // CESMRMeetingTimeValidator::StartDateChandedL

   917 // ---------------------------------------------------------------------------

   918 //

   919 void CESMRMeetingTimeValidator::StartDateChandedL()

   920     {

   921     FUNC_LOG;

   922     PreValidateEditorContent();    

   923     HandleStartTimeChangeL();

   924     HandleAlarmTimeChangedL();

   925     DrawEditorsDeferred();

   926     SendFieldChangeEventL( EESMRFieldStartDate );

   927     }

   928 

   929 // ---------------------------------------------------------------------------

   930 // CESMRMeetingTimeValidator::EndDateChangedL

   931 // ---------------------------------------------------------------------------

   932 //

   933 void CESMRMeetingTimeValidator::EndDateChangedL()

   934     {

   935     FUNC_LOG;

   936     TInt err( KErrNone );

   937 

   938     PreValidateEditorContent();

   939 

   940     TTime start = StartDateTime();

   941     TTime end = EndDateTime();

   942 

   943     if ( end < start )

   944         {

   945         err = KErrArgument;

   946         }

   947 

   948     if ( err == KErrNone )

   949         {

   950         HandleEndTimeChangeL();

   951         HandleAlarmTimeChangedL();

   952         }

   953     else

   954         {

   955         SetTimeToEditor( *iEndTime, iCurrentEndTime );

   956         SetDateToEditor( *iEndDate, iCurrentEndTime );

   957         }

   958 

   959     DrawEditorsDeferred();

   960     User::LeaveIfError( err );

   961     }

   962 

   963 // ---------------------------------------------------------------------------

   964 // CESMRMeetingTimeValidator::AlarmTimeChangedL

   965 // ---------------------------------------------------------------------------

   966 //

   967 void CESMRMeetingTimeValidator::AlarmTimeChangedL()

   968     {

   969     FUNC_LOG;

   970     AlarmDateChangedL();

   971     }

   972 

   973 // ---------------------------------------------------------------------------

   974 // CESMRMeetingTimeValidator::AlarmDateChangedL

   975 // ---------------------------------------------------------------------------

   976 //

   977 void CESMRMeetingTimeValidator::AlarmDateChangedL()

   978     {

   979     FUNC_LOG;

   980     if ( iAlarmOnOff && iAlarmTime && iAlarmDate && iAlldayEvent )

   981         {

   982         PreValidateEditorContent();

   983         HandleAlarmTimeChangedL();

   984         DrawEditorsDeferred();

   985         }

   986     }

   987 

   988 // ---------------------------------------------------------------------------

   989 // CESMRMeetingTimeValidator::RelativeAlarmChangedL

   990 // ---------------------------------------------------------------------------

   991 //

   992 void CESMRMeetingTimeValidator::RelativeAlarmChangedL(

   993                                 TTimeIntervalMinutes aCurrentAlarmTimeOffset,

   994                                 TBool aHandleAlarmChange,

   995                                 TBool& aRelativeAlarmValid )

   996     {

   997     FUNC_LOG;

   998     iRelativeAlarmValid = &aRelativeAlarmValid;

   999     iCurrentAlarmTimeOffset = aCurrentAlarmTimeOffset;

  1000 

  1001     if ( aHandleAlarmChange )

  1002         {

  1003         HandleRelativeAlarmTimeChangedL();

  1004         }

  1005     }

  1006 

  1007 // ---------------------------------------------------------------------------

  1008 // CESMRMeetingTimeValidator::SetAllDayEventL

  1009 // ---------------------------------------------------------------------------

  1010 //

  1011 void CESMRMeetingTimeValidator::SetAllDayEventL(

  1012         TBool aAlldayEvent )

  1013     {

  1014     FUNC_LOG;

  1015     if ( iAlldayEvent != aAlldayEvent )

  1016         {

  1017         iAlldayEvent = aAlldayEvent;

  1018 

  1019         if ( iAlldayEvent )

  1020             {

  1021             iStartTimeBeforeAlldayEvent = iCurrentStartTime;

  1022             iEndTimeBeforeAlldayEvent = iCurrentEndTime;

  1023 

  1024             TTime start = StartDateTime();

  1025             iCurrentStartTime = StartDateTime();

  1026             iCurrentEndTime = EndDateTime();

  1027 

  1028             if ( iAlarmOnOff )

  1029                 {

  1030                 TTime alarm = DefaultAlldayEventAlarmTime( start );

  1031                 SetTimeToEditor( *iAlarmTime, alarm );

  1032                 SetDateToEditor( *iAlarmDate, alarm );

  1033                 iCurrentAlarmTime = alarm;

  1034                 }

  1035 

  1036             DrawEditorsDeferred();

  1037             }

  1038         else

  1039             {

  1040             SetTimeToEditor( *iStartTime, iStartTimeBeforeAlldayEvent );

  1041             SetTimeToEditor( *iEndTime, iEndTimeBeforeAlldayEvent );

  1042 

  1043             TTime start = StartDateTime();

  1044             TTime end = EndDateTime();

  1045 

  1046             if ( start > end )

  1047                 {

  1048                 // User has modified dates so that end time

  1049                 // is earlier than start time

  1050                 end = start;

  1051                 }

  1052 

  1053             SetTimeToEditor( *iStartTime, start );

  1054             SetDateToEditor( *iStartDate, start );

  1055 

  1056             SetTimeToEditor( *iEndTime, end );

  1057             SetDateToEditor( *iEndDate, end );

  1058 

  1059             iCurrentStartTime = start;

  1060             iCurrentEndTime = end;

  1061 

  1062             DrawEditorsDeferred();

  1063             }

  1064         }

  1065     }

  1066 

  1067 // ---------------------------------------------------------------------------

  1068 // CESMRMeetingTimeValidator::SetAlarmOnOffL

  1069 // ---------------------------------------------------------------------------

  1070 //

  1071 void CESMRMeetingTimeValidator::SetAlarmOnOffL(

  1072         TBool aAlarmOn )

  1073     {

  1074     FUNC_LOG;

  1075     iAlarmOnOff = aAlarmOn;

  1076     if( iAlarmOnOff )

  1077         {

  1078         iAbsoluteAlarmController->SetAbsoluteAlarmOn();

  1079         }

  1080     else

  1081         {

  1082         iAbsoluteAlarmController->SetAbsoluteAlarmOff();

  1083         }

  1084 

  1085     if ( iAlarmOnOff && iAlldayEvent )

  1086         {

  1087         if ( iCurrentAlarmTime > iCurrentStartTime ||

  1088              iCurrentAlarmTime == Time::NullTTime() )

  1089             {

  1090             iCurrentAlarmTime = 

  1091 				DefaultAlldayEventAlarmTime( iCurrentStartTime );

  1092             SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );

  1093             SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );

  1094             }

  1095         }

  1096     }

  1097 

  1098 // ---------------------------------------------------------------------------

  1099 // CESMRMeetingTimeValidator::RecurrenceChangedL

  1100 // ---------------------------------------------------------------------------

  1101 //

  1102 void CESMRMeetingTimeValidator::RecurrenceChangedL(

  1103         TESMRRecurrenceValue aRecurrence )

  1104     {

  1105     FUNC_LOG;

  1106     if ( aRecurrence != iRecurrenceValue )

  1107         {

  1108 

  1109         TDateTime start = StartDateTime();

  1110         TDateTime end = EndDateTime();

  1111 

  1112         if ( start.Day() != end.Day() ||

  1113              start.Month() != end.Month() ||

  1114              start.Year() != end.Year())

  1115             {

  1116             User::Leave( KErrArgument );

  1117             }

  1118 

  1119         iRecurrenceValue = aRecurrence;

  1120         PreValidateEditorContent();

  1121         HandleRecurrenceTypeChanged();

  1122         DrawEditorsDeferred();

  1123         }

  1124 

  1125     }

  1126 

  1127 // ---------------------------------------------------------------------------

  1128 // CESMRMeetingTimeValidator::RecurrenceEndDateChangedL

  1129 // ---------------------------------------------------------------------------

  1130 //

  1131 void CESMRMeetingTimeValidator::RecurrenceEndDateChangedL()

  1132     {

  1133     FUNC_LOG;

  1134     PreValidateEditorContent();

  1135     HandleRecurrenceEndDateChangedL();