140 { |
98 { |
141 TRACE_ENTRY_POINT; |
99 TRACE_ENTRY_POINT; |
142 |
100 |
143 TBool continueCommand(EFalse); |
101 TBool continueCommand(EFalse); |
144 TInt command = aCommand.Command(); |
102 TInt command = aCommand.Command(); |
145 |
103 MCalenContext& context = iController.Services().Context(); |
146 switch(command) |
104 AgendaEntry editedEntry; |
|
105 QDateTime newEntryDateTime = iController.context().focusDateAndTimeL(); |
|
106 |
|
107 // Check if it is not on same day and set the default time and date accordingly. |
|
108 bool isSameDay = CalenDateUtils::isOnToday(newEntryDateTime); |
|
109 if (!isSameDay) { |
|
110 newEntryDateTime = CalenDateUtils::defaultTime(newEntryDateTime); |
|
111 } |
|
112 switch ( command ) |
147 { |
113 { |
148 case ECalenNewMeeting: |
114 case ECalenNewMeeting: |
149 case ECalenNewDayNote: |
115 iEditor= new CalenEditor(iController.Services().agendaInterface()); |
150 |
116 iEditor->create(newEntryDateTime, false, CalenEditor::TypeAppointment ); |
151 { |
117 connect(iEditor, SIGNAL(entrySaved()), this, SLOT(handleEntrySaved())); |
152 TUid currentView = iController.ViewManager().CurrentView(); |
118 connect(iEditor, SIGNAL(dialogClosed()), this, SLOT(handleDialogClosed())); |
153 if( KUidCalenTodoView == currentView ) |
119 break; |
154 { |
120 case ECalenEditCurrentEntry: |
155 // Open NewEntry as "To-Do", if editor is launched from To-Do view. |
121 editedEntry = iController.Services().agendaInterface()->fetchById( |
156 EditNewEntryL( CCalEntry::ETodo ); |
122 context.instanceId().mEntryLocalUid ); |
157 } |
123 // For repeating entry, we need to update proper start time here |
158 else |
124 // from the context |
159 { |
125 if (editedEntry.isRepeating()) { |
160 EditNewEntryL(); |
126 // Get the instancde time frm the context |
161 } |
127 QDateTime instanceTime = context.focusDateAndTimeL(); |
|
128 editedEntry.setStartAndEndTime(instanceTime, editedEntry.endTime()); |
162 } |
129 } |
163 break; |
130 iEditor= new CalenEditor(iController.Services().agendaInterface()); |
164 case ECalenNewTodo: |
131 iEditor->edit(editedEntry, false); |
165 EditNewEntryL( CCalEntry::ETodo ); |
132 connect(iEditor, SIGNAL(entrySaved()), this, SLOT(handleEntrySaved())); |
166 break; |
133 connect(iEditor, SIGNAL(dialogClosed()), this, SLOT(handleDialogClosed())); |
167 case ECalenNewAnniv: |
|
168 EditNewEntryL( CCalEntry::EAnniv ); |
|
169 break; |
|
170 case ECalenNewMeetingRequest: |
|
171 { |
|
172 EditNewMeetingRequestL(); |
|
173 } |
|
174 break; |
|
175 case ECalenEditCurrentEntry: |
|
176 case ECalenEditSeries: |
|
177 case ECalenEditOccurrence: |
|
178 case ECalenCompleteTodo: |
|
179 case ECalenRestoreTodo: |
|
180 case ECalenMarkEntryAsDone: |
|
181 case ECalenMarkEntryAsUnDone: |
|
182 { |
|
183 // These commands need the entry view |
|
184 // to be constructed before being called |
|
185 CCalEntryView* entryView = iGlobalData->EntryViewL(); |
|
186 if( !entryView ) |
|
187 { |
|
188 // Store the command and wait for notification |
|
189 WaitForEntryViewNotificationL( aCommand ); |
|
190 } |
|
191 else |
|
192 { |
|
193 switch ( command ) |
|
194 { |
|
195 case ECalenEditCurrentEntry: |
|
196 { |
|
197 MCalenContext& context = iGlobalData->Context(); |
|
198 entryView = iGlobalData->EntryViewL(context.InstanceId().iColId); |
|
199 CCalEntry* entry = entryView->FetchL( |
|
200 context.InstanceId().iEntryLocalUid ); |
|
201 CleanupStack::PushL( entry ); |
|
202 User::LeaveIfNull( entry ); |
|
203 EditEntryL( entry, |
|
204 context.InstanceId().iInstanceTime, |
|
205 MAgnEntryUi::EEditExistingEntry ); |
|
206 |
|
207 CleanupStack::PopAndDestroy( entry ); |
|
208 |
|
209 break; |
|
210 } |
|
211 case ECalenCompleteTodo: |
|
212 SetTodoCompleteL( ETrue ); |
|
213 break; |
|
214 case ECalenRestoreTodo: |
|
215 SetTodoCompleteL( EFalse ); |
|
216 break; |
|
217 case ECalenMarkEntryAsDone: |
|
218 continueCommand = SetMultipleTodoCompleteL(ETrue ); |
|
219 break; |
|
220 case ECalenMarkEntryAsUnDone: |
|
221 continueCommand = SetMultipleTodoCompleteL(EFalse ); |
|
222 break; |
|
223 default: |
|
224 { |
|
225 // Should never reach this point. |
|
226 ASSERT( EFalse ); |
|
227 } |
|
228 } |
|
229 } |
|
230 } |
|
231 break; |
|
232 case ECalenSend: |
|
233 { |
|
234 iGlobalData->CalenSendL().DisplaySendCascadeMenuL(); |
|
235 |
|
236 if( iGlobalData->CalenSendL().CanSendL( ECalenSend ) ) |
|
237 { |
|
238 SendEntryL(); |
|
239 iController.BroadcastNotification( ECalenNotifyEntrySent ); |
|
240 } |
|
241 // ECalenNotifyDialogClosed issued when Messaging Query is cancelled |
|
242 // by the user. |
|
243 else |
|
244 { |
|
245 iController.BroadcastNotification( ECalenNotifyDialogClosed ); |
|
246 } |
|
247 |
|
248 } |
|
249 break; |
134 break; |
250 default: |
135 default: |
251 // Controller decided this class was the place to handle this |
136 // Controller decided this class was the place to handle this |
252 // command |
137 // command |
253 break; |
138 break; |
254 } |
139 } |
255 |
140 |
256 TRACE_EXIT_POINT; |
141 TRACE_EXIT_POINT; |
257 return continueCommand; |
142 return continueCommand; |
258 } |
143 } |
259 |
144 |
260 // ---------------------------------------------------------------------------- |
145 // ---------------------------------------------------------------------------- |
261 // CCalenEditUi::CalenCommandHandlerExtensionL |
146 // CCalenEditUi::handleEntrySaved |
262 // Dummy implementation. |
147 // Issues the entry saved notification after receiving signal from editor. |
263 // (other items were commented in a header). |
|
264 // ---------------------------------------------------------------------------- |
148 // ---------------------------------------------------------------------------- |
265 // |
149 // |
266 TAny* CCalenEditUi::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ ) |
150 void CCalenEditUi::handleEntrySaved() |
267 { |
151 { |
268 TRACE_ENTRY_POINT; |
152 iController.Services().IssueNotificationL(ECalenNotifyEntrySaved); |
269 TRACE_EXIT_POINT; |
153 } |
270 return NULL; |
|
271 } |
|
272 |
154 |
273 // ---------------------------------------------------------------------------- |
155 // ---------------------------------------------------------------------------- |
274 // CCalenEditUi::SetTodoCompleteL |
156 // CCalenEditUi::handleEntrySaved |
275 // Completes or restores a todo. |
157 // Issues the dialog closed notification after receiving signal from editor. |
276 // (other items were commented in a header). |
|
277 // ---------------------------------------------------------------------------- |
158 // ---------------------------------------------------------------------------- |
278 // |
159 // |
279 void CCalenEditUi::SetTodoCompleteL( TBool aComplete ) |
160 void CCalenEditUi::handleDialogClosed() |
280 { |
161 { |
281 TRACE_ENTRY_POINT; |
162 iController.Services().IssueNotificationL(ECalenNotifyDialogClosed); |
|
163 } |
282 |
164 |
283 MCalenContext& context = iGlobalData->Context(); |
|
284 ASSERT( !( context.InstanceId() == ( TCalenInstanceId::NullInstanceId() ) ) ); |
|
285 |
|
286 // HandleActionUiCommandL creates the entry view if it has |
|
287 // not already been created before SetTodoCompleteL is called. |
|
288 CCalEntryView* entryView = iGlobalData->EntryViewL(context.InstanceId().iColId); |
|
289 ASSERT( entryView ); |
|
290 |
|
291 CCalEntry* entry = entryView->FetchL( context.InstanceId().iEntryLocalUid ); |
|
292 |
|
293 CleanupStack::PushL( entry ); |
|
294 |
|
295 if( entry ) |
|
296 { |
|
297 CalenActionUiUtils::SetToDoCompleteStatusL( *entryView, entry, aComplete ); |
|
298 //iContainer->NotifyEntryChangeL( *entry, entry->StartTimeL() ); |
|
299 iController.BroadcastNotification( ECalenNotifyEntrySaved ); |
|
300 } |
|
301 |
|
302 CleanupStack::PopAndDestroy( entry ); |
|
303 |
|
304 TRACE_EXIT_POINT; |
|
305 } |
|
306 |
|
307 // ---------------------------------------------------------------------------- |
|
308 // CCalenEditUi::SetTodoEntryCompleteL |
|
309 // Completes or restores a todo. |
|
310 // (other items were commented in a header). |
|
311 // ---------------------------------------------------------------------------- |
|
312 // |
|
313 void CCalenEditUi::SetTodoEntryCompleteL(TBool aComplete,TCalLocalUid aEntryUid,TCalCollectionId colId) |
|
314 { |
|
315 TRACE_ENTRY_POINT; |
|
316 |
|
317 // HandleActionUiCommandL creates the entry view if it has |
|
318 // not already been created before SetTodoCompleteL is called. |
|
319 CCalEntryView* entryView = iGlobalData->EntryViewL(colId); |
|
320 ASSERT( entryView ); |
|
321 |
|
322 CCalEntry* entry = entryView->FetchL( aEntryUid ); |
|
323 CleanupStack::PushL( entry ); |
|
324 |
|
325 if( entry ) |
|
326 { |
|
327 CalenActionUiUtils::SetToDoCompleteStatusL( *entryView, entry, aComplete ); |
|
328 } |
|
329 |
|
330 CleanupStack::PopAndDestroy( entry ); |
|
331 TRACE_EXIT_POINT; |
|
332 } |
|
333 |
|
334 // ---------------------------------------------------------------------------- |
|
335 // CCalenEditUi::EditNewEntryL |
|
336 // Creates a new entry and opens it for editing |
|
337 // (other items were commented in a header). |
|
338 // ---------------------------------------------------------------------------- |
|
339 // |
|
340 void CCalenEditUi::EditNewEntryL( CCalEntry::TType aEntryType) |
|
341 { |
|
342 TRACE_ENTRY_POINT; |
|
343 |
|
344 // Create unique ID. |
|
345 HBufC8* guid = iGlobalData->InterimUtilsL().GlobalUidL(); |
|
346 CleanupStack::PushL( guid ); |
|
347 CCalEntry* entry = CCalEntry::NewL( aEntryType, guid, CCalEntry::EMethodNone, 0 ); |
|
348 CleanupStack::Pop( guid ); |
|
349 |
|
350 CleanupStack::PushL( entry ); |
|
351 |
|
352 // Set initial start and end times from Calendar context |
|
353 TTime focusedTime = CalculateActiveTimeFromContextL(); |
|
354 TCalTime initialCalTime; |
|
355 |
|
356 initialCalTime.SetTimeLocalL( focusedTime ); |
|
357 |
|
358 entry->SetStartAndEndTimeL( initialCalTime, initialCalTime ); |
|
359 |
|
360 if( entry->EntryTypeL()==CCalEntry::EAnniv ) |
|
361 { |
|
362 TCalRRule rrule( TCalRRule::EYearly ); |
|
363 TCalTime startDate; |
|
364 rrule.SetDtStart( initialCalTime ); |
|
365 rrule.SetInterval( 1 ); // once a year |
|
366 entry->SetRRuleL( rrule ); |
|
367 } |
|
368 |
|
369 MCalenContext& context = iGlobalData->Context(); |
|
370 TCalCollectionId colId = context.InstanceId().iColId; |
|
371 TCalenInstanceId id = TCalenInstanceId::CreateL( *entry, initialCalTime ); |
|
372 id.iColId = colId; |
|
373 |
|
374 context.SetInstanceIdL( id, context.ViewId() ); |
|
375 |
|
376 TTime instanceTime = entry->StartTimeL().TimeLocalL(); |
|
377 EditEntryL( entry, instanceTime, MAgnEntryUi::ECreateNewEntry ); |
|
378 CleanupStack::PopAndDestroy( entry ); |
|
379 |
|
380 TRACE_EXIT_POINT; |
|
381 } |
|
382 |
|
383 // ---------------------------------------------------------------------------- |
|
384 // CCalenEditUi::EditNewMeetingRequestL |
|
385 // Creates a new meeting request and opens it for editing |
|
386 // (other items were commented in a header). |
|
387 // ---------------------------------------------------------------------------- |
|
388 // |
|
389 void CCalenEditUi::EditNewMeetingRequestL() |
|
390 { |
|
391 TRACE_ENTRY_POINT; |
|
392 |
|
393 CMRMailboxUtils::TMailboxInfo defaultMailBox; |
|
394 |
|
395 if( !iGlobalData->AttemptToRetrieveDefaultMailboxL( defaultMailBox ) ) |
|
396 { |
|
397 // User either doesn't have any mailboxes or didn't select a default mailbox. |
|
398 // Don't create the meeting request. |
|
399 TRACE_EXIT_POINT; |
|
400 return; |
|
401 } |
|
402 |
|
403 // If we got this far, defaultMailBox should be initialised. |
|
404 HBufC8* guid = iGlobalData->InterimUtilsL().GlobalUidL(); |
|
405 |
|
406 CleanupStack::PushL( guid ); |
|
407 CCalEntry* entry = CCalEntry::NewL( CCalEntry::EAppt, |
|
408 guid, |
|
409 CCalEntry::EMethodRequest, |
|
410 0 ); |
|
411 CleanupStack::Pop( guid ); |
|
412 CleanupStack::PushL( entry ); |
|
413 |
|
414 // Set initial start and end times from Active Calendar Context |
|
415 TTime focusedTime = iGlobalData->Context().FocusDateAndTimeL().TimeLocalL(); |
|
416 TCalTime initialCalTime; |
|
417 // No need to handle floating time check here, as meetings are |
|
418 // always fixed. |
|
419 initialCalTime.SetTimeLocalL( focusedTime ); |
|
420 |
|
421 entry->SetStartAndEndTimeL( initialCalTime, initialCalTime ); |
|
422 |
|
423 //Set the organizer from the selected mailbox |
|
424 CCalUser* organizer = CCalUser::NewL( defaultMailBox.iEmailAddress ); |
|
425 entry->SetOrganizerL( organizer ); |
|
426 |
|
427 TTime instanceTime = entry->StartTimeL().TimeLocalL(); |
|
428 EditEntryL( entry, instanceTime, MAgnEntryUi::ECreateNewEntry ); |
|
429 CleanupStack::PopAndDestroy( entry ); |
|
430 |
|
431 TRACE_EXIT_POINT; |
|
432 } |
|
433 |
|
434 // ---------------------------------------------------------------------------- |
|
435 // CCalenEditUi::EditEntryL |
|
436 // Opens the entry aEntry for editing |
|
437 // (other items were commented in a header). |
|
438 // ---------------------------------------------------------------------------- |
|
439 // |
|
440 void CCalenEditUi::EditEntryL( CCalEntry* aEntry, |
|
441 const TTime& aInstanceDate, |
|
442 MAgnEntryUi::TAgnEntryUiEditorMode aEditorMode ) |
|
443 { |
|
444 TRACE_ENTRY_POINT; |
|
445 |
|
446 // Set the flag |
|
447 isEditorActive = ETrue; |
|
448 |
|
449 if( !iEditorsPlugin ) |
|
450 { |
|
451 //Only created on first use |
|
452 LoadEditorsPluginL(); |
|
453 if( !iEditorsPlugin ) |
|
454 { |
|
455 // User was prompted to set a default mailbox and hit cancel |
|
456 // Entry will not be opened |
|
457 TRACE_EXIT_POINT; |
|
458 return; |
|
459 } |
|
460 } |
|
461 |
|
462 MAgnEntryUi::TAgnEntryUiInParams inParams( KUidCalendar, |
|
463 iGlobalData->CalSessionL(), |
|
464 aEditorMode ); |
|
465 |
|
466 // Use floating time for non-timed entries |
|
467 if( !CalenAgendaUtils::IsTimedEntryL(aEntry->EntryTypeL()) ) |
|
468 { |
|
469 inParams.iInstanceDate.SetTimeLocalFloatingL( aInstanceDate ); |
|
470 } |
|
471 else |
|
472 { |
|
473 inParams.iInstanceDate.SetTimeLocalL( aInstanceDate ); |
|
474 } |
|
475 |
|
476 inParams.iMsgSession = NULL; |
|
477 |
|
478 MAgnEntryUi::TAgnEntryUiOutParams outParams; |
|
479 |
|
480 // Launch Entry UI |
|
481 RPointerArray<CCalEntry> entries; |
|
482 CleanupClosePushL( entries ); |
|
483 entries.AppendL( aEntry ); // aEntry already in cleanup stack -> safe |
|
484 |
|
485 // Editors need a services implementation. |
|
486 MCalenServices* svc = CCalenServicesImpl::NewL(); |
|
487 CleanupReleasePushL( *svc ); |
|
488 inParams.iSpare = ( TInt )svc; |
|
489 |
|
490 |
|
491 // Stop the population of the current view |
|
492 iController.ViewManager().InterruptPopulationL(); |
|
493 |
|
494 // hide the toolbar |
|
495 MCalenToolbar* toolbar = iController.Services().ToolbarOrNull(); |
|
496 if(toolbar) |
|
497 { |
|
498 toolbar->SetToolbarVisibilityL(EFalse); |
|
499 } |
|
500 |
|
501 |
|
502 // If a menubar is active,stop displaying it before launching editor |
|
503 TUid viewUid = iController.ViewManager().CurrentView(); |
|
504 CEikMenuBar* menuBar = iController.AppUi().View(viewUid)->MenuBar(); |
|
505 if(menuBar) |
|
506 { |
|
507 menuBar->StopDisplayingMenuBar(); |
|
508 } |
|
509 |
|
510 // Launch the viewer / editor plugin |
|
511 iEditorsPlugin->ExecuteViewL( entries, inParams, outParams, *this ); |
|
512 |
|
513 // Reset the flag |
|
514 isEditorActive = EFalse; |
|
515 |
|
516 // Unhide the toolbar when settings is closed |
|
517 if(toolbar) |
|
518 { |
|
519 toolbar->SetToolbarVisibilityL(ETrue); |
|
520 } |
|
521 |
|
522 CleanupStack::PopAndDestroy( svc ); |
|
523 |
|
524 // Close the entries array |
|
525 CleanupStack::PopAndDestroy( &entries ); |
|
526 |
|
527 switch( outParams.iAction ) |
|
528 { |
|
529 case MAgnEntryUi::EMeetingSaved: |
|
530 case MAgnEntryUi::EInstanceRescheduled: |
|
531 { |
|
532 // Update context and issue notification before confirmation dialog |
|
533 // to avoid delay of updating title pane |
|
534 MCalenContext& context = iGlobalData->Context(); |
|
535 TCalCollectionId colId = context.InstanceId().iColId; |
|
536 TCalenInstanceId id = TCalenInstanceId::CreateL( TCalLocalUid( |
|
537 outParams.iSpare), |
|
538 outParams.iNewInstanceDate.TimeLocalL(), EFalse ); |
|
539 id.iColId = colId; |
|
540 id.iType = context.InstanceId().iType; |
|
541 if( aEditorMode != MAgnEntryUi::ECreateNewEntry ) |
|
542 { |
|
543 id.iInstanceTime = context.InstanceId().iInstanceTime; |
|
544 } |
|
545 context.SetInstanceIdL( id, context.ViewId() ); |
|
546 iController.BroadcastNotification( ECalenNotifyEntrySaved ); |
|
547 |
|
548 if( aEditorMode == MAgnEntryUi::ECreateNewEntry ) |
|
549 { |
|
550 // Show saved note for new entries |
|
551 TInt res; |
|
552 if( aEntry->EntryTypeL() == CCalEntry::ETodo ) |
|
553 { |
|
554 res = R_QTN_CALE_NOTE_TODO_SAVED; |
|
555 } |
|
556 else |
|
557 { |
|
558 res = R_TEXT_CALENDAR_NOTE_SAVED; |
|
559 } |
|
560 |
|
561 HBufC* prompt = StringLoader::LoadLC( res, CEikonEnv::Static() ); |
|
562 CAknConfirmationNote* dialog = new( ELeave )CAknConfirmationNote(); |
|
563 dialog->ExecuteLD( *prompt ); |
|
564 CleanupStack::PopAndDestroy( prompt ); |
|
565 } |
|
566 } |
|
567 break; |
|
568 |
|
569 case MAgnEntryUi::EMeetingDeleted: |
|
570 iController.BroadcastNotification( ECalenNotifyEntryDeleted ); |
|
571 break; |
|
572 |
|
573 case MAgnEntryUi::EInstanceDeleted: |
|
574 iController.BroadcastNotification( ECalenNotifyInstanceDeleted ); |
|
575 break; |
|
576 |
|
577 case MAgnEntryUi::ENoAction: |
|
578 default: |
|
579 iController.BroadcastNotification( ECalenNotifyEntrySaved ); |
|
580 break; |
|
581 } |
|
582 |
|
583 |
|
584 TRACE_EXIT_POINT; |
|
585 } |
|
586 |
|
587 // ---------------------------------------------------------------------------- |
|
588 // CCalenEditUi::LoadEditorsPluginL |
|
589 // Attempts to load the editors plugin into iEditorsPlugin. If failure occurs |
|
590 // (for example, if the user is prompted to select a default mailbox and hits |
|
591 // cancel), iEditorsPlugin is set to NULL. |
|
592 // (other items were commented in a header). |
|
593 // ---------------------------------------------------------------------------- |
|
594 // |
|
595 void CCalenEditUi::LoadEditorsPluginL() |
|
596 { |
|
597 TRACE_ENTRY_POINT; |
|
598 |
|
599 delete iEditorsPlugin; |
|
600 iEditorsPlugin = NULL; |
|
601 |
|
602 if( iGlobalData->InterimUtilsL().MRViewersEnabledL() ) |
|
603 { |
|
604 //Get the currently selected mailbox |
|
605 CMRMailboxUtils::TMailboxInfo defaultMailBox; |
|
606 |
|
607 if( iGlobalData->AttemptToRetrieveDefaultMailboxL( defaultMailBox ) ) |
|
608 { |
|
609 //CAgnEntryUi resolves Meeting request viewer based on mtm uid |
|
610 TBuf8<KMaxUidName> mrMtm; |
|
611 CnvUtfConverter::ConvertFromUnicodeToUtf8( mrMtm, |
|
612 defaultMailBox.iMtmUid.Name() ); |
|
613 iEditorsPlugin = CAgnEntryUi::NewL( mrMtm ); |
|
614 } |
|
615 } |
|
616 else |
|
617 { |
|
618 iEditorsPlugin = CCalenEditorsPlugin::NewL(); |
|
619 } |
|
620 |
|
621 TRACE_EXIT_POINT; |
|
622 } |
|
623 |
|
624 |
|
625 // ---------------------------------------------------------------------------- |
|
626 // CCalenEditUi::SendEntryL |
|
627 // Sends the current entry. |
|
628 // (other items were commented in a header). |
|
629 // ---------------------------------------------------------------------------- |
|
630 // |
|
631 void CCalenEditUi::SendEntryL() |
|
632 { |
|
633 TRACE_ENTRY_POINT; |
|
634 |
|
635 MCalenContext& context = iGlobalData->Context(); |
|
636 ASSERT( !( context.InstanceId() == TCalenInstanceId::NullInstanceId() ) ); |
|
637 |
|
638 //If todo, use the LUid. |
|
639 //Todos returns the current time if start or end time has not been saved. |
|
640 if( CCalEntry::ETodo == context.InstanceId().iType ) |
|
641 { |
|
642 CCalEntry* entry = iGlobalData->EntryViewL(context.InstanceId().iColId)->FetchL( |
|
643 context.InstanceId().iEntryLocalUid ); |
|
644 if( entry ) |
|
645 { |
|
646 CleanupStack::PushL( entry ); |
|
647 iGlobalData->CalenSendL().SendAsVCalendarL( ECalenSend, *entry ); |
|
648 CleanupStack::PopAndDestroy( entry ); |
|
649 } |
|
650 } |
|
651 else // Not todo |
|
652 { |
|
653 RArray<TInt> colIdArray; |
|
654 CleanupClosePushL(colIdArray); |
|
655 iController.GetActiveCollectionidsL(colIdArray); |
|
656 |
|
657 CCalInstance* instance = CalenActionUiUtils::FindPossibleInstanceL( |
|
658 context.InstanceId(), |
|
659 *iGlobalData->InstanceViewL(colIdArray) ); |
|
660 CleanupStack::PushL( instance ); |
|
661 |
|
662 if( instance ) |
|
663 { |
|
664 CCalEntry& entry = instance->Entry(); |
|
665 iGlobalData->CalenSendL().SendAsVCalendarL( ECalenSend, entry ); |
|
666 } |
|
667 |
|
668 CleanupStack::PopAndDestroy( instance ); |
|
669 CleanupStack::PopAndDestroy(&colIdArray); |
|
670 } |
|
671 |
|
672 TRACE_EXIT_POINT; |
|
673 } |
|
674 |
|
675 // ---------------------------------------------------------------------------- |
|
676 // CCalenEditUi::ProcessCommandWithResultL |
|
677 // This is pure virtual from MAgnEntryUiCallback. We don't use it. |
|
678 // (other items were commented in a header). |
|
679 // ---------------------------------------------------------------------------- |
|
680 // |
|
681 TInt CCalenEditUi::ProcessCommandWithResultL( TInt /*aCommandId*/ ) |
|
682 { |
|
683 TRACE_ENTRY_POINT; |
|
684 TRACE_EXIT_POINT; |
|
685 return KErrNone; |
|
686 } |
|
687 |
|
688 // ---------------------------------------------------------------------------- |
|
689 // CCalenEditUi::ProcessCommandL |
|
690 // This is pure virtual from MAgnEntryUiCallback. We don't use it. |
|
691 // (other items were commented in a header). |
|
692 // ---------------------------------------------------------------------------- |
|
693 // |
|
694 void CCalenEditUi::ProcessCommandL( TInt /*aCommandId*/ ) |
|
695 { |
|
696 TRACE_ENTRY_POINT; |
|
697 TRACE_EXIT_POINT; |
|
698 } |
|
699 |
|
700 // ---------------------------------------------------------------------------- |
|
701 // CCalenEditUi::WaitForEntryViewNotificationL |
|
702 // Register for view created notification |
|
703 // (other items were commented in a header). |
|
704 // ---------------------------------------------------------------------------- |
|
705 // |
|
706 void CCalenEditUi::WaitForEntryViewNotificationL( const TCalenCommand& aCommand ) |
|
707 { |
|
708 TRACE_ENTRY_POINT; |
|
709 |
|
710 iStoredCommand = aCommand; |
|
711 |
|
712 // Only wait for an entry view if it doesn't already exist |
|
713 ASSERT( !( iGlobalData->EntryViewL() ) ); |
|
714 |
|
715 // Register for notifications |
|
716 iController.RegisterForNotificationsL( this, ECalenNotifyEntryInstanceViewCreated ); |
|
717 |
|
718 TRACE_EXIT_POINT; |
|
719 } |
|
720 |
|
721 // ---------------------------------------------------------------------------- |
|
722 // CCalenEditUi::HandleECalenNotifyViewCreatedL |
|
723 // Handle ECalenNotifyViewCreated |
|
724 // (other items were commented in a header). |
|
725 // ---------------------------------------------------------------------------- |
|
726 // |
|
727 void CCalenEditUi::HandleECalenNotifyViewCreatedL() |
|
728 { |
|
729 TRACE_ENTRY_POINT; |
|
730 |
|
731 if( iGlobalData->EntryViewL() ) |
|
732 { |
|
733 // Handle the outstanding command |
|
734 HandleCommandL( iStoredCommand ); |
|
735 |
|
736 // Cancel the notify as the entry view is now |
|
737 // constructed. |
|
738 iController.CancelNotifications( this ); |
|
739 } |
|
740 |
|
741 TRACE_EXIT_POINT; |
|
742 } |
|
743 // ---------------------------------------------------------------------------- |
165 // ---------------------------------------------------------------------------- |
744 // CCalenEditUi::HandleNotification |
166 // CCalenEditUi::HandleNotification |
745 // Handle notifications |
167 // Handle notifications |
746 // (other items were commented in a header). |
168 // (other items were commented in a header). |
747 // ---------------------------------------------------------------------------- |
169 // ---------------------------------------------------------------------------- |
748 // |
170 // |
749 void CCalenEditUi::HandleNotification(const TCalenNotification aNotification ) |
171 void CCalenEditUi::HandleNotification(const TCalenNotification aNotification ) |
750 { |
172 { |
751 TRACE_ENTRY_POINT; |
173 TRACE_ENTRY_POINT; |
752 |
174 |
753 if ( aNotification == ECalenNotifyEntryInstanceViewCreated ) |
175 if( aNotification == ECalenNotifyDialogClosed ) |
754 { |
176 { |
755 PIM_TRAPD_HANDLE( HandleECalenNotifyViewCreatedL() ); |
177 iEditor->deleteLater(); |
756 } |
178 } |
757 if( aNotification == ECalenNotifyCancelStatusUpdation) |
|
758 { |
|
759 if(iMutlipleContextIdsCount) |
|
760 { |
|
761 // get the context |
|
762 MCalenContext& context = iGlobalData->Context(); |
|
763 // reset the multiple contexts |
|
764 context.ResetMultipleContextIds(); |
|
765 |
|
766 // dismiss the waitdialog |
|
767 if(iWaitDialog) |
|
768 { |
|
769 TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); |
|
770 } |
|
771 } |
|
772 } |
|
773 TRACE_EXIT_POINT; |
179 TRACE_EXIT_POINT; |
774 } |
180 } |
775 |
181 |
776 TBool CCalenEditUi::SetMultipleTodoCompleteL(TBool aComplete ) |
|
777 { |
|
778 TRACE_ENTRY_POINT; |
|
779 TBool continueCommand(EFalse); |
|
780 |
|
781 // get the context |
|
782 MCalenContext& context = iGlobalData->Context(); |
|
783 |
|
784 // get the multliple context ids count |
|
785 iMutlipleContextIdsCount = context.MutlipleContextIdsCount(); |
|
786 |
|
787 ASSERT( iMutlipleContextIdsCount ); |
|
788 |
|
789 if(!iMoreEntriesToComplete) |
|
790 { |
|
791 DisplayWaitDialogL(); |
|
792 } |
|
793 // get the multiple context instance ids |
|
794 RArray<TCalenInstanceId>& multipleContextIds = context.GetMutlipleContextIds(); |
|
795 |
|
796 if(iMutlipleContextIdsCount <= iEntriesToComplete ) |
|
797 { |
|
798 iMoreEntriesToComplete = EFalse; |
|
799 iEntriesToComplete = iMutlipleContextIdsCount; |
|
800 } |
|
801 else |
|
802 { |
|
803 iMoreEntriesToComplete = ETrue; |
|
804 // set the continue command flag if more entries are there to delete |
|
805 continueCommand = ETrue; |
|
806 } |
|
807 |
|
808 TInt index(0); |
|
809 while(index<iEntriesToComplete) |
|
810 { |
|
811 // get the local uid of the entry through multiple context list |
|
812 TCalLocalUid entryLocalUid = multipleContextIds[0].iEntryLocalUid; |
|
813 TCalCollectionId colId = multipleContextIds[0].iColId; |
|
814 if(entryLocalUid) |
|
815 { |
|
816 SetTodoEntryCompleteL(aComplete, entryLocalUid,colId); |
|
817 } |
|
818 // remove mutliple context based on the instanceid |
|
819 context.RemoveMultipleContextId(multipleContextIds[0]); |
|
820 index++; |
|
821 } |
|
822 |
|
823 if(!iMoreEntriesToComplete) |
|
824 { |
|
825 MarkedEntriesCompletedL(); |
|
826 } |
|
827 |
|
828 |
|
829 |
|
830 TRACE_EXIT_POINT; |
|
831 return continueCommand; |
|
832 } |
|
833 // ----------------------------------------------------------------------------- |
|
834 // CCalenEditUi::DisplayWaitDialogL |
|
835 // Display wait dialog |
|
836 // ----------------------------------------------------------------------------- |
|
837 // |
|
838 void CCalenEditUi::DisplayWaitDialogL() |
|
839 { |
|
840 TRACE_ENTRY_POINT; |
|
841 |
|
842 delete iWaitDialog; |
|
843 iWaitDialog = NULL; |
|
844 iWaitDialog = new( ELeave )CAknWaitDialog( REINTERPRET_CAST( CEikDialog**, &iWaitDialog ), ETrue ); |
|
845 iWaitDialog->ExecuteLD( R_TODO_UPDATING_STATUS_NOTE ); |
|
846 iWaitDialog->SetCallback(this); |
|
847 |
|
848 TRACE_EXIT_POINT; |
|
849 } |
|
850 |
|
851 // ----------------------------------------------------------------------------- |
|
852 // CCalenEditUi::MarkedEntriesDeletedL |
|
853 // Dismiss wait dialog and show information note |
|
854 // ----------------------------------------------------------------------------- |
|
855 // |
|
856 void CCalenEditUi::MarkedEntriesCompletedL() |
|
857 { |
|
858 TRACE_ENTRY_POINT; |
|
859 |
|
860 // dismiss the waitdialog |
|
861 if(iWaitDialog) |
|
862 { |
|
863 iWaitDialog->ProcessFinishedL(); |
|
864 } |
|
865 |
|
866 if(iMutlipleContextIdsCount) |
|
867 { |
|
868 // get the context |
|
869 MCalenContext& context = iGlobalData->Context(); |
|
870 // reset the multiple contexts |
|
871 context.ResetMultipleContextIds(); |
|
872 } |
|
873 // notify marked entries deleted |
|
874 iController.BroadcastNotification( ECalenNotifyMarkedEntryCompleted ); |
|
875 |
|
876 TRACE_EXIT_POINT; |
|
877 } |
|
878 |
|
879 void CCalenEditUi::DialogDismissedL( const TInt /*aButtonId*/ ) |
|
880 { |
|
881 TRACE_ENTRY_POINT; |
|
882 |
|
883 // no more entries to delete |
|
884 iMoreEntriesToComplete = EFalse; |
|
885 |
|
886 // issue notification cancel delete |
|
887 // iController.BroadcastNotification(ECalenNotifyCancelStatusUpdation); |
|
888 |
|
889 TRACE_EXIT_POINT; |
|
890 } |
|
891 |
|
892 // ----------------------------------------------------------------------------- |
|
893 // CCalenEditUi::CalculateActiveTimeFromContextL |
|
894 // CCalculate active time from context |
|
895 // ----------------------------------------------------------------------------- |
|
896 // |
|
897 TTime CCalenEditUi::CalculateActiveTimeFromContextL() |
|
898 { |
|
899 TRACE_ENTRY_POINT; |
|
900 // The active time is calculated based on the following table |
|
901 // Current View |
|
902 // Month Day Week ToDo |
|
903 |
|
904 // Meeting* CFD (@8am) CFD (@8am) CFD @ FCT Today (@8am) |
|
905 // Day Note CFD CFD CFD Today |
|
906 // Anniv* CFD CFD CFD Today |
|
907 // ToDo* CFD CFD CFD Today |
|
908 |
|
909 // CFD = Currently Focused Date, the one shown in Navigator toolbar |
|
910 // FCT = Focused Cell's Time, applicable only to Week View |
|
911 // (*) Alarm Default times are also set using the values |
|
912 |
|
913 TTime activeTime(Time::NullTTime()); // initialize with NULL time |
|
914 TTime& activeTimeRef = activeTime; |
|
915 MCalenContext &context = iGlobalData->Context(); |
|
916 TUid currentView = iController.ViewManager().CurrentView(); |
|
917 if(currentView == KUidCalenWeekView) |
|
918 { |
|
919 // use CFD |
|
920 activeTime = CalenDateUtils::BeginningOfDay( |
|
921 context.FocusDateAndTimeL().TimeLocalL()); // CFD |
|
922 |
|
923 // CFD @ FCT |
|
924 // focus on empty nontimed cell |
|
925 if( context.FocusDateAndTimeL().TimeUtcL() == Time::NullTTime() ) |
|
926 { |
|
927 activeTime = CalenDateUtils::DefaultTime( activeTimeRef ); |
|
928 } |
|
929 else if(context.InstanceId().iType != CCalEntry::EAppt) |
|
930 { |
|
931 activeTime = CalenDateUtils::DefaultTime( activeTimeRef ); |
|
932 } |
|
933 else |
|
934 { |
|
935 activeTime += CalenDateUtils::TimeOfDay( |
|
936 context.FocusDateAndTimeL().TimeLocalL().DateTime() ); |
|
937 } |
|
938 } |
|
939 else |
|
940 { |
|
941 // use Today @ 8 am |
|
942 activeTime = CalenDateUtils::Today(); |
|
943 activeTime = CalenDateUtils::DefaultTime(context.FocusDateAndTimeL().TimeLocalL()); // 8 am |
|
944 } |
|
945 |
|
946 TRACE_EXIT_POINT; |
|
947 return activeTime; |
|
948 } |
|
949 |
|
950 // ----------------------------------------------------------------------------- |
|
951 // CCalenEditUi::IsEditorActive |
|
952 // Tells framework whether editor is active or not |
|
953 // ----------------------------------------------------------------------------- |
|
954 // |
|
955 TBool CCalenEditUi::IsEditorActive() |
|
956 { |
|
957 return isEditorActive; |
|
958 } |
|
959 // End of file |
182 // End of file |