22 #include "esmrconfig.hrh"

    49 #include "emailtrace.h"

    50 

    67 // Definition for max hours, minutes, seconds in day for Memo

    68 const TInt KMaxHoursForMemo( 23 );

    69 const TInt KMaxMinutesForMemo( 59 );

    70 const TInt KMaxSecondsForMemo( 59 );

    71 

    72 // Definition for max hours, minutes, seconds in day for To-Do

    73 const TInt KMaxHoursForTodo( 23 );

    74 const TInt KMaxMinutesForTodo( 59 );

    75 const TInt KMaxSecondsForTodo( 00 );

    76 

    77 const TInt KDefaultAnniversaryAlarmHours( 12 );

    78 

    79 const TInt KDefaultTodoAlarmHours( 12 );

    80 

    81 // Definition for default alarm time for meeting

    82 const TInt KDefaultMeetingAlarmMinutes( 15 );

    83 

    84 // Constant for default meeeting start hour

    85 const TInt KDefaultMeetingStartHour( 8 );

    86 

    87 // Constant for default meeeting end hour

    88 const TInt KDefaultMeetingEndHour( 9 );

    89 

    90 

   111 

   112 CCalEntry::TType MapType( TESMRCalendarEventType aEntryType )

   113     {

   114     CCalEntry::TType type( CCalEntry::EAppt );

   115 

   116     switch ( aEntryType )

   117         {

   118         case EESMREventTypeAppt:

   119         case EESMREventTypeMeetingRequest:

   120             {

   121             type = CCalEntry::EAppt;

   122             break;

   123             }

   124         case EESMREventTypeETodo:

   125             {

   126             type = CCalEntry::ETodo;

   127             break;

   128             }

   129         case EESMREventTypeEEvent:

   130             {

   131             type = CCalEntry::EEvent;

   132             break;

   133             }

   134         case EESMREventTypeEReminder:

   135             {

   136             type = CCalEntry::EReminder;

   137             break;

   138             }

   139         case EESMREventTypeEAnniv:

   140             {

   141             type = CCalEntry::EAnniv;

   142             break;

   143             }

   144         default:

   145             {

   146             __ASSERT_DEBUG( EFalse, Panic( EInvalidEntryType ) );

   147             }

   148         }

   149 

   150     return type;

   151     }

   152 

   153 /**

   154  * Fetches the supported mailboxes.

   155  * @param aMBUtils utils class

   156  * @param aMailBoxes to test

   157  */

   158 void SupportedMailboxesL(

   159         CMRMailboxUtils& aMBUtils,

   160         RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )

   161     {

   162     FUNC_LOG;

   163     aMBUtils.ListMailBoxesL( aMailBoxes );

   164 

   165     RCPointerArray<CImplementationInformation> implArray;

   166     CleanupClosePushL( implArray );

   167 

   168     //Get all MRViewers Implementation

   169     const TUid mrViewersIface = TUid::Uid(KMRViewersInterfaceUID);

   170     REComSession::ListImplementationsL(mrViewersIface, implArray );

   171     TInt mrviewerCount( implArray.Count() );

   172 

   173     TInt index(0);

   174     TInt mailboxCount( aMailBoxes.Count() );

   175     while ( index < mailboxCount )

   176          {

   177          TBool supported( EFalse );

   178 

   179          for ( TInt i(0); (i < mrviewerCount) && !supported; ++ i )

   180              {

   181              TBuf16<KMaxUidName> mbName;

   182              CnvUtfConverter::ConvertToUnicodeFromUtf8(

   183                      mbName,

   184                      implArray[i]->DataType() );

   185 

   186              if( aMailBoxes[index].iMtmUid.Name().CompareF(mbName) == 0)

   187                   {

   188                   supported = ETrue;

   189                  }

   190              }

   191 

   192          if ( supported )

   193              {

   194              index++;

   195              }

   196          else

   197              {

   198              aMailBoxes.Remove( index );

   199              mailboxCount = aMailBoxes.Count();

   200              }

   201          }

   202     CleanupStack::PopAndDestroy( &implArray );

   203     }

   204 

   205 /**

   206  * Prompts user to select default mailbox.

   207  * @param aMailBoxes Reference to mailbox list

   208  */

   209 TInt PromptForDefaultMailboxL(

   210         RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )

   211     {

   212     FUNC_LOG;

   213     TInt selected( KErrCancel );

   214 

   215     TInt mbCount = aMailBoxes.Count();

   216     if( mbCount > 0)

   217         {

   218         CAknSinglePopupMenuStyleListBox* list =

   219             new (ELeave) CAknSinglePopupMenuStyleListBox;

   220         CleanupStack::PushL(list);

   221 

   222         CAknPopupList* popupList = CAknPopupList::NewL(

   223                                             list,

   224                                             R_AVKON_SOFTKEYS_OK_CANCEL);

   225         CleanupStack::PushL(popupList);

   226 

   227         list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);

   228         list->CreateScrollBarFrameL(ETrue);

   229         list->ScrollBarFrame()->SetScrollBarVisibilityL(

   230             CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

   231 

   232         CEikonEnv* eikEnv = CEikonEnv::Static();// codescanner::eikonenvstatic

   233 

   234         CDesCArrayFlat* items = new (ELeave)CDesCArrayFlat(mbCount);

   235         CleanupStack::PushL(items);

   236         for(TInt i=0; i<mbCount; ++i)

   237             {

   238             items->AppendL( aMailBoxes[i].iName );

   239             }

   240         CleanupStack::Pop(items);

   241         CTextListBoxModel* model = list->Model();

   242 

   243         //Pass ownersip of items to model

   244         model->SetItemTextArray(items);

   245 

   246         HBufC* title = KNullDesC().AllocLC();

   247         popupList->SetTitleL(*title);

   248         CleanupStack::PopAndDestroy(title);

   249 

   250         TBool accepted = popupList->ExecuteLD();

   251         CleanupStack::Pop( popupList );

   252 

   253         if(accepted)

   254             {

   255             selected = list->CurrentItemIndex();

   256             }

   257         else

   258             {

   259             selected = KErrCancel;

   260             }

   261 

   262         CleanupStack::PopAndDestroy( list );

   263         }

   264     else

   265         {

   266         //No mailboxes defined.  Could prompt user to define one here.

   267         selected = KErrCancel;

   268         }

   269 

   270     return selected;

   271     }

   272 

   273 /**

   274  * Converts to-do specific priority to normal priority

   275  * @param Calendar entry, which priority is converted

   276  */

   277 void ConvertTodoPriorityToNormalL( CCalEntry& entry )

   278     {

   279     FUNC_LOG;

   280     TInt priority( 0 );

   281     if( entry.PriorityL() == EFSCalenTodoPriorityHigh )

   282         {

   283         priority = EFSCalenMRPriorityHigh;

   284         }

   285 

   286     else if( entry.PriorityL() == EFSCalenTodoPriorityNormal )

   287         {

   288         priority = EFSCalenMRPriorityNormal;

   289         }

   290 

   291     else if( entry.PriorityL() == EFSCalenTodoPriorityLow )

   292         {

   293         priority = EFSCalenMRPriorityLow;

   294         }

   295 

   296     else

   297         {

   298         // Priority unknown, let's set it to normal then

   299         priority = EFSCalenMRPriorityNormal;

   300         }

   301 

   302     entry.SetPriorityL( priority );

   303     }

   812 // ----------------------------------------------------------------------------

   813 // ESMRHelper::CreateAndAppendOthersDirToFileName

   814 // ----------------------------------------------------------------------------

   815 //

   816 EXPORT_C TInt ESMRHelper::CreateAndAppendOthersDirToFileName(

   817             TFileName& aFileName)

   818     {

   819     FUNC_LOG;

   820 

   821     TFileName path;

   822     RFs fsSession;

   823     TInt result = fsSession.Connect();

   824     if ( KErrNone == result )

   825         {

   826         aFileName.Insert(0, PathInfo::OthersPath() );

   827         aFileName.Insert(0, PathInfo::PhoneMemoryRootPath() );

   828 

   829         fsSession.MkDirAll(aFileName);

   830 

   831         result = KErrNone;

   832         }

   833 

   834     // fsSession

   835     fsSession.Close();

   836     return result;

   837     }

   838 

   839 // ----------------------------------------------------------------------------

   840 // ESMRHelper::CopyEntryAndSwitchTypeL

   841 // ----------------------------------------------------------------------------

   842 //

   843 CCalEntry* ESMRHelper::CopyEntryAndSwitchTypeL(

   844         const CCalEntry& aSourceEntry,

   845         TESMRCalendarEventType aTargetType )

   846     {

   847     FUNC_LOG;

   848     CCalEntry* entry = NULL;

   849 

   850     TESMRSwitchEventType switchType;

   851 

   852     switchType = ResolveSwitchType(

   853             ESMREntryHelper::EventTypeL( aSourceEntry ), aTargetType );

   854 

   855     switch ( switchType )

   856         {

   857         case EMRSwitchMRToMeeting:

   858             {

   859             entry = SwitchToMeetingL( aSourceEntry );

   860             break;

   861             }

   862         case EMRSwitchMRToMemo:

   863             {

   864             entry = SwitchToMemoL( aSourceEntry );

   865             break;

   866             }

   867         case EMRSwitchMRToAnniversary:

   868             {

   869             entry = SwitchToAnniversaryL( aSourceEntry );

   870             break;

   871             }

   872         case EMRSwitchMRToTodo:

   873             {

   874             entry = SwitchToTodoL( aSourceEntry );

   875             break;

   876             }

   877         case EMRSwitchMeetingToMR:

   878             {

   879             entry = SwitchToMRL( aSourceEntry );

   880             break;

   881             }

   882         case EMRSwitchMeetingToMemo:

   883             {

   884             entry = SwitchToMemoL( aSourceEntry );

   885             break;

   886             }

   887         case EMRSwitchMeetingToAnniversary:

   888             {

   889             entry = SwitchToAnniversaryL( aSourceEntry );

   890             break;

   891             }

   892         case EMRSwitchMeetingToTodo:

   893             {

   894             entry = SwitchToTodoL( aSourceEntry );

   895             break;

   896             }

   897         case EMRSwitchMemoToMR:

   898             {

   899             entry = SwitchToMRL( aSourceEntry );

   900             break;

   901             }

   902         case EMRSwitchMemoToMeeting:

   903             {

   904             entry = SwitchToMeetingL( aSourceEntry );

   905             break;

   906             }

   907         case EMRSwitchMemoToAnniversary:

   908             {

   909             entry = SwitchToAnniversaryL( aSourceEntry );

   910             break;

   911             }

   912         case EMRSwitchMemoToTodo:

   913             {

   914             entry = SwitchToTodoL( aSourceEntry );

   915             break;

   916             }

   917         case EMRSwitchAnniversaryToMR:

   918             {

   919             entry = SwitchToMRL( aSourceEntry );

   920             break;

   921             }

   922         case EMRSwitchAnniversaryToMeeting:

   923             {

   924             entry = SwitchToMeetingL( aSourceEntry );

   925             break;

   926             }

   927         case EMRSwitchAnniversaryToMemo:

   928             {

   929             entry = SwitchToMemoL( aSourceEntry );

   930             break;

   931             }

   932         case EMRSwitchAnniversaryToTodo:

   933             {

   934             entry = SwitchToTodoL( aSourceEntry );

   935             break;

   936             }

   937         case EMRSwitchTodoToMR:

   938             {

   939             entry = SwitchToMRL( aSourceEntry );

   940             break;

   941             }

   942         case EMRSwitchTodoToMeeting:

   943             {

   944             entry = SwitchToMeetingL( aSourceEntry );

   945             break;

   946             }

   947         case EMRSwitchTodoToMemo:

   948             {

   949             entry = SwitchToMemoL( aSourceEntry );

   950             break;

   951             }

   952         case EMRSwitchTodoToAnniversary:

   953             {

   954             entry = SwitchToAnniversaryL( aSourceEntry );

   955             break;

   956             }

   957 

   958         default:

   959             {

   960             __ASSERT_DEBUG( EFalse, Panic( EInvalidEntryType ) );

   961             }

   962         }

   963 

   964     return entry;

   965     }

   966 

   967 // ----------------------------------------------------------------------------

   968 // ESMRHelper::ResolveSwitchType

   969 // ----------------------------------------------------------------------------

   970 //

   971 ESMRHelper::TESMRSwitchEventType ESMRHelper::ResolveSwitchType(

   972         TESMRCalendarEventType aSourceType,

   973         TESMRCalendarEventType aTargetType )

   974     {

   975     FUNC_LOG;

   976 

   977     TESMRSwitchEventType type( EMRSwitchUnknown );

   978 

   979     if( aSourceType == EESMREventTypeMeetingRequest ) // Meeting request

   980         {

   981         if( aTargetType == EESMREventTypeAppt )

   982             {

   983             type = EMRSwitchMRToMeeting;

   984             }

   985 

   986         if( aTargetType == EESMREventTypeEEvent )

   987              {

   988              type = EMRSwitchMRToMemo;

   989              }

   990 

   991         if( aTargetType == EESMREventTypeEAnniv )

   992              {

   993              type = EMRSwitchMRToAnniversary;

   994              }

   995 

   996         if( aTargetType == EESMREventTypeETodo )

   997              {

   998              type = EMRSwitchMRToTodo;

   999              }

  1000         }

  1001 

  1002     if( aSourceType == EESMREventTypeAppt ) // Meeting

  1003         {

  1004         if( aTargetType == EESMREventTypeMeetingRequest )

  1005             {

  1006             type = EMRSwitchMeetingToMR;

  1007             }

  1008 

  1009         if( aTargetType == EESMREventTypeEEvent )

  1010              {

  1011              type = EMRSwitchMeetingToMemo;

  1012              }

  1013 

  1014         if( aTargetType == EESMREventTypeEAnniv )

  1015              {

  1016              type = EMRSwitchMeetingToAnniversary;

  1017              }

  1018 

  1019         if( aTargetType == EESMREventTypeETodo )

  1020              {

  1021              type = EMRSwitchMeetingToTodo;

  1022              }

  1023         }

  1024 

  1025     if( aSourceType == EESMREventTypeEEvent ) // Memo

  1026         {

  1027         if( aTargetType == EESMREventTypeMeetingRequest )

  1028             {

  1029             type = EMRSwitchMemoToMR;

  1030             }

  1031 

  1032         if( aTargetType == EESMREventTypeAppt )

  1033              {

  1034              type = EMRSwitchMemoToMeeting;

  1035              }

  1036 

  1037         if( aTargetType == EESMREventTypeEAnniv )

  1038              {

  1039              type = EMRSwitchMemoToAnniversary;

  1040              }

  1041 

  1042         if( aTargetType == EESMREventTypeETodo )

  1043              {

  1044              type = EMRSwitchMemoToTodo;

  1045              }

  1046         }

  1047 

  1048     if( aSourceType == EESMREventTypeEAnniv ) // Anniversary

  1049         {

  1050         if( aTargetType == EESMREventTypeMeetingRequest )

  1051             {

  1052             type = EMRSwitchAnniversaryToMR;

  1053             }

  1054 

  1055         if( aTargetType == EESMREventTypeAppt  )

  1056              {

  1057              type = EMRSwitchAnniversaryToMeeting;

  1058              }

  1059 

  1060         if( aTargetType == EESMREventTypeEEvent  )

  1061              {

  1062              type = EMRSwitchAnniversaryToMemo;

  1063              }

  1064 

  1065         if( aTargetType == EESMREventTypeETodo )

  1066              {

  1067              type = EMRSwitchAnniversaryToTodo;

  1068              }

  1069         }

  1070 

  1071     if( aSourceType == EESMREventTypeETodo ) // To-do

  1072         {

  1073         if( aTargetType == EESMREventTypeMeetingRequest )

  1074             {

  1075             type = EMRSwitchTodoToMR;

  1076             }

  1077 

  1078         if( aTargetType == EESMREventTypeAppt )

  1079              {

  1080              type = EMRSwitchTodoToMeeting;

  1081              }

  1082 

  1083         if( aTargetType == EESMREventTypeEEvent )

  1084              {

  1085              type = EMRSwitchTodoToMemo;

  1086              }

  1087 

  1088         if( aTargetType == EESMREventTypeEAnniv )

  1089              {

  1090              type = EMRSwitchTodoToAnniversary;

  1091              }

  1092         }

  1093 

  1094     __ASSERT_DEBUG( type != EMRSwitchUnknown, Panic( EInvalidSwitchType ) );

  1095 

  1096     return type;

  1097     }

  1098 

  1099 // ----------------------------------------------------------------------------

  1100 // ESMRHelper::SwitchToMemoL

  1101 // ----------------------------------------------------------------------------

  1102 //

  1103 CCalEntry* ESMRHelper::SwitchToMemoL(

  1104         const CCalEntry& aSourceEntry )

  1105     {

  1106     FUNC_LOG;

  1107     CCalEntry* entry = CreateEntryL(

  1108                 CCalEntry::EEvent,

  1109                 aSourceEntry.UidL(),

  1110                 CCalEntry::EMethodNone,

  1111                 CalCommon::EThisOnly );

  1112 

  1113     CleanupStack::PushL( entry );

  1114 

  1115     // Copy all data from existing entry to new entry

  1116     entry->CopyFromL( aSourceEntry );

  1117     // We must re-set the method to the original value

  1118     entry->SetMethodL( CCalEntry::EMethodNone );

  1119 

  1120 #ifdef RD_USE_PS2_APIS

  1121     // If source entry is a meeting request...

  1122     if( CCalenInterimUtils2::IsMeetingRequestL( *entry ) )

  1123         {

  1124         // ... we need to clear all MR specific data

  1125         entry->ClearMRSpecificDataL();

  1126         }

  1127 #endif // RD_USE_PS2_APIS

  1128 

  1129     // Memo is never a repeating event

  1130     entry->ClearRepeatingPropertiesL();

  1131 

  1132     // Memo has start and stop date without time value.

  1133     // Let's change the entry's start and stop times to memo specific

  1134     // Setting start date and stop date

  1135     TDateTime start = entry->StartTimeL().TimeLocalL().DateTime();

  1136     start.SetHour( 0 );

  1137     start.SetMinute( 0 );

  1138     start.SetSecond( 0 );

  1139 

  1140     TTime tempEnd = entry->EndTimeL().TimeLocalL();

  1141 

  1142     if( ESMREntryHelper::IsAllDayEventL( aSourceEntry ) )

  1143         {

  1144         // If source is all day event, we need to reduce one from the day,

  1145         // otherwise the new memo would be spanned over one day too long

  1146         tempEnd -= TTimeIntervalDays( 1 );

  1147         }

  1148 

  1149     TDateTime end = tempEnd.DateTime();

  1150     end.SetHour( KMaxHoursForMemo );

  1151     end.SetMinute( KMaxMinutesForMemo );

  1152     end.SetSecond( KMaxSecondsForMemo );

  1153 

  1154     TCalTime startDate;

  1155     startDate.SetTimeLocalFloatingL( start );

  1156     TCalTime stopDate;

  1157     stopDate.SetTimeLocalFloatingL( end );

  1158     entry->SetStartAndEndTimeL( startDate, stopDate );

  1159 

  1160     // Memo does not have any alarm value

  1161     entry->SetAlarmL( NULL );

  1162 

  1163     // If source entry is to-do, we need to convert the

  1164     // priority from to-do priority to normal priority

  1165     if( aSourceEntry.EntryTypeL() == CCalEntry::ETodo )

  1166         {

  1167         ConvertTodoPriorityToNormalL( *entry );

  1168         }

  1169 

  1170     CleanupStack::Pop( entry ); // ownership transferred to caller

  1171     return entry;

  1172     }

  1173 

  1174 // ----------------------------------------------------------------------------

  1175 // ESMRHelper::SwitchToAnniversaryL

  1176 // ----------------------------------------------------------------------------

  1177 //

  1178 CCalEntry* ESMRHelper::SwitchToAnniversaryL(

  1179         const CCalEntry& aSourceEntry )

  1180     {

  1181     FUNC_LOG;

  1182     // Create an entry

  1183     CCalEntry* entry = CreateEntryL(

  1184             CCalEntry::EAnniv,

  1185             aSourceEntry.UidL(),

  1186             CCalEntry::EMethodNone,

  1187             CalCommon::EThisOnly );

  1188 

  1189     CleanupStack::PushL( entry );

  1190 

  1191     // Copy all data from existing entry to new entry

  1192     entry->CopyFromL( aSourceEntry );

  1193     // We must re-set the method to the original value

  1194     entry->SetMethodL( CCalEntry::EMethodNone );

  1195 

  1196 #ifdef RD_USE_PS2_APIS

  1197     // If source entry is a meeting request...

  1198     if( CCalenInterimUtils2::IsMeetingRequestL( *entry ) )

  1199         {

  1200         // ... we need to clear all MR specific data

  1201         entry->ClearMRSpecificDataL();

  1202         }

  1203 #endif // RD_USE_PS2_APIS

  1204 

  1205     // Anniversary repeats once a year, so

  1206     // we clear existing repeating rules...

  1207     entry->ClearRepeatingPropertiesL();

  1208 

  1209     // ... and create a new rule, to repeat once a year

  1210     TCalRRule rrule( TCalRRule::EYearly );

  1211     rrule.SetDtStart( entry->StartTimeL() );

  1212     rrule.SetInterval( 1 );

  1213     rrule.SetCount( 0 );

  1214     entry->SetRRuleL( rrule );

  1215 

  1216     // Anniversary default alarm is previous day at noon.

  1217     // Let's set that also.

  1218     TTime eventTime = entry->StartTimeL().TimeLocalL();

  1219     TTime alarmTime = eventTime - TTimeIntervalDays( 1 );

  1220     TDateTime alarmDateTime = alarmTime.DateTime();

  1221     alarmDateTime.SetHour( KDefaultAnniversaryAlarmHours );

  1222     alarmDateTime.SetMinute( 0 );

  1223     alarmDateTime.SetSecond( 0 );

  1224     alarmDateTime.SetMicroSecond( 0 );

  1225     alarmTime = alarmDateTime;

  1226 

  1227     // Calculating alarm offset

  1228     TTimeIntervalMinutes alarmOffset( 0 );

  1229     eventTime.MinutesFrom( alarmTime, alarmOffset );

  1230 

  1231     // Creating alarm

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

  1233     CleanupStack::PushL( alarm );

  1234     alarm->SetTimeOffset( alarmOffset );

  1235 

  1236     // Setting alarm

  1237     entry->SetAlarmL( alarm );

  1238     CleanupStack::PopAndDestroy( alarm );

  1239     alarm = NULL;

  1240 

  1241     // If source entry is to-do, we need to convert the

  1242     // priority from to-do priority to normal priority

  1243     if( aSourceEntry.EntryTypeL() == CCalEntry::ETodo )

  1244         {

  1245         ConvertTodoPriorityToNormalL( *entry );

  1246         }

  1247 

  1248     CleanupStack::Pop( entry ); // ownership transferred to caller

  1249     return entry;

  1250     }

  1251 

  1252 // ----------------------------------------------------------------------------

  1253 // ESMRHelper::SwitchToTodoL

  1254 // ----------------------------------------------------------------------------

  1255 //

  1256 CCalEntry* ESMRHelper::SwitchToTodoL(

  1257         const CCalEntry& aSourceEntry )

  1258     {

  1259     FUNC_LOG;

  1260     CCalEntry* entry = CreateEntryL(

  1261             CCalEntry::ETodo,

  1262             aSourceEntry.UidL(),

  1263             CCalEntry::EMethodNone,

  1264             CalCommon::EThisOnly );

  1265 

  1266     CleanupStack::PushL( entry );

  1267 

  1268     // Copy all data from existing entry to new entry

  1269     entry->CopyFromL( aSourceEntry );

  1270     // We must re-set the method to the original value

  1271     entry->SetMethodL( CCalEntry::EMethodNone );

  1272 

  1273 #ifdef RD_USE_PS2_APIS

  1274     // If source entry is a meeting request...

  1275     if( CCalenInterimUtils2::IsMeetingRequestL( *entry ) )

  1276         {

  1277         // ... we need to clear all MR specific data

  1278         entry->ClearMRSpecificDataL();

  1279         }

  1280 #endif // RD_USE_PS2_APIS

  1281 

  1282     // To-do is never a repeating event

  1283     entry->ClearRepeatingPropertiesL();

  1284 

  1285     // To-do has a due date only. Let's change the entry's start and stop

  1286     // times to To-do specific ones

  1287     TTime tempEnd = entry->EndTimeL().TimeLocalL();

  1288 

  1289     if( ESMREntryHelper::IsAllDayEventL( aSourceEntry ) )

  1290         {

  1291         // If source is all day event, we need to reduce one from the day,

  1292         // otherwise the new todos due date would be one day late

  1293         tempEnd -= TTimeIntervalDays( 1 );

  1294         }

  1295 

  1296     TDateTime tempDue = tempEnd.DateTime();

  1297 

  1298     tempDue.SetHour( KMaxHoursForTodo );

  1299     tempDue.SetMinute( KMaxMinutesForTodo );

  1300     tempDue.SetSecond( KMaxSecondsForTodo );

  1301 

  1302     TCalTime dueDate;

  1303     dueDate.SetTimeLocalFloatingL( tempDue );

  1304 

  1305     entry->SetStartAndEndTimeL( dueDate, dueDate );

  1306 

  1307     // Setting to-do specific alarm

  1308     if( entry->AlarmL() )

  1309         {

  1310         // Setting default To-do alarm for entry

  1311         TTime eventTime = entry->EndTimeL().TimeLocalL();

  1312 

  1313         // Calculate alarm time (due date at 12:00am)

  1314         TTime alarmTime = eventTime;

  1315         TDateTime alarmDateTime = alarmTime.DateTime();

  1316         alarmDateTime.SetHour( KDefaultTodoAlarmHours );

  1317         alarmDateTime.SetMinute( 0 );

  1318         alarmDateTime.SetSecond( 0 );

  1319         alarmDateTime.SetMicroSecond( 0 );

  1320         alarmTime = alarmDateTime;

  1321 

  1322         TTime currentTime;

  1323         currentTime.HomeTime();

  1324 

  1325         // If alarm is in the future

  1326         if ( alarmTime > currentTime )

  1327             {

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

  1329             CleanupStack::PushL( alarm );

  1330             TTimeIntervalMinutes alarmOffset( 0 );

  1331             eventTime.MinutesFrom( alarmTime, alarmOffset );

  1332             alarm->SetTimeOffset( alarmOffset );

  1333             entry->SetAlarmL( alarm );

  1334             CleanupStack::PopAndDestroy( alarm );

  1335             }

  1336         // Alarm is in the past, let's set it to NULL

  1337         else

  1338             {

  1339             entry->SetAlarmL( NULL );

  1340             }

  1341         }

  1342 

  1343     // Setting to-do specific priority

  1344     TInt priority( 0 );

  1345     if( entry->PriorityL() == EFSCalenMRPriorityHigh )

  1346         {

  1347         priority = EFSCalenTodoPriorityHigh;

  1348         }

  1349 

  1350     else if( entry->PriorityL() == EFSCalenMRPriorityNormal )

  1351         {

  1352         priority = EFSCalenTodoPriorityNormal;

  1353         }

  1354 

  1355     else if( entry->PriorityL() == EFSCalenMRPriorityLow )

  1356         {

  1357         priority = EFSCalenTodoPriorityLow;

  1358         }

  1359 

  1360     else

  1361         {

  1362         // Priority unknown, let's set it to normal then

  1363         priority = EFSCalenTodoPriorityNormal;

  1364         }

  1365 

  1366     entry->SetPriorityL( priority );

  1367 

  1368     CleanupStack::Pop( entry ); // ownership transferred to caller

  1369     return entry;

  1370     }

  1371 

  1372 // ----------------------------------------------------------------------------

  1373 // ESMRHelper::SwitchToMeetingL

  1374 // ----------------------------------------------------------------------------

  1375 //

  1376 CCalEntry* ESMRHelper::SwitchToMeetingL(

  1377         const CCalEntry& aSourceEntry )

  1378     {

  1379     FUNC_LOG;

  1380 

  1381     CCalEntry* entry = CreateEntryL(

  1382             CCalEntry::EAppt,

  1383             aSourceEntry.UidL(),

  1384             CCalEntry::EMethodNone,

  1385             CalCommon::EThisOnly );

  1386 

  1387     CleanupStack::PushL( entry );

  1388 

  1389     // Copy all data from existing entry to new entry

  1390     entry->CopyFromL( aSourceEntry );

  1391 

  1392     // If source was to-do, priority needs converting

  1393     if( aSourceEntry.EntryTypeL() == CCalEntry::ETodo )

  1394     	{

  1395 		ConvertTodoPriorityToNormalL( *entry );

  1396     	}

  1397 

  1398     // We must re-set the method to the original value

  1399     entry->SetMethodL( CCalEntry::EMethodNone );

  1400 

  1401 #ifdef RD_USE_PS2_APIS

  1402     // If source entry is a meeting request...

  1403     if( CCalenInterimUtils2::IsMeetingRequestL( *entry ) )

  1404         {

  1405         // ... we need to clear all MR specific data,

  1406         // but otherwise the enrty is now converted

  1407         // correctly from MR to meeting

  1408         entry->ClearMRSpecificDataL();

  1409         }

  1410     else

  1411 #endif // RD_USE_PS2_APIS

  1412         {

  1413         // Repeating rules from memo, to-do and anniversary

  1414         // are not compatible with a meeting

  1415         entry->ClearRepeatingPropertiesL();

  1416 

  1417         // Setting meeting time, since memo, to-do and anniversary

  1418         // start / end times are not compatible with meeting's corresponding

  1419         // values

  1420         SetMeetingTimeL( *entry, aSourceEntry );

  1421 

  1422         // If source is not an appointment, we'll set default

  1423         // alarm for meeting, since memo, to-do and anniversary

  1424         // alarms are not compatible with meeting alarm

  1425         if( entry->AlarmL() &&

  1426                 aSourceEntry.EntryTypeL() != CCalEntry::EAppt )

  1427             {

  1428             SetDefaultAlarmForMeetingL( *entry );

  1429             }

  1430 

  1431         // If source entry is to-do, we need to convert the

  1432         // priority from to-do priority to normal priority

  1433         if( aSourceEntry.EntryTypeL() == CCalEntry::ETodo )

  1434             {

  1435             ConvertTodoPriorityToNormalL( *entry );

  1436             }

  1437         }

  1438 

  1439     CleanupStack::Pop( entry ); // ownership transferred to caller

  1440     return entry;