/*
* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Controller class for editing related UI behavior
*
*/
#include <eikenv.h>
#include <e32math.h>
#include <StringLoader.h>
#include <utf.h>
#include <aknnotewrappers.h>
#include <avkon.hrh>
#include <CAgnEntryUi.h>
#include <calentryview.h>
#include <calentry.h>
#include <calrrule.h>
#include <caluser.h>
#include <calenagendautils.h>
#include <calendateutils.h>
#include <CalenInterimUtils2.h>
#include <CalenEditorsPlugin.h>
#include <calenglobaldata.h>
#include <Calendar.rsg>
#include <calencommonui.rsg>
#include <calencommands.hrh> // Calendar commands
#include <calencontext.h>
#include <caleninstanceid.h> // TCalenInstanceId
#include <calentoolbar.h>
#include <calenactionuiutils.h>
#include <aknViewAppUi.h> // CAknViewAppUi
#include <aknview.h>
#include "calendarui_debug.h"
#include "caleneditui.h"
#include "calencontroller.h"
#include "calendar.hrh"
#include "calensend.h"
#include "CalenUid.h"
#include "calenservicesimpl.h"
#include "calenviewmanager.h"
// ----------------------------------------------------------------------------
// CCalenEditUi::NewL
// First stage construction
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
CCalenEditUi* CCalenEditUi::NewL( CCalenController& aController )
{
TRACE_ENTRY_POINT;
CCalenEditUi* self = new(ELeave) CCalenEditUi( aController );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
TRACE_EXIT_POINT;
return self;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::~CCalenEditUi
// Destructor
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
CCalenEditUi::~CCalenEditUi()
{
TRACE_ENTRY_POINT;
delete iEditorsPlugin;
delete iListItems;
delete iListItemCommands;
if( iWaitDialog )
{
delete iWaitDialog;
}
if( iGlobalData )
{
iGlobalData->Release();
}
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::CCalenEditUi
// Constructor
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
CCalenEditUi::CCalenEditUi( CCalenController& aController )
: iController( aController )
{
TRACE_ENTRY_POINT;
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::ConstructL
// Second stage construction
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::ConstructL()
{
TRACE_ENTRY_POINT;
iGlobalData = CCalenGlobalData::InstanceL();
iEntriesToComplete = 1;
iMoreEntriesToComplete = EFalse;
isEditorActive = EFalse;
iController.RegisterForNotificationsL( this, ECalenNotifyCancelStatusUpdation );
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::HandleActionUiCommandL
// Handles action ui commands
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
TBool CCalenEditUi::HandleCommandL( const TCalenCommand& aCommand )
{
TRACE_ENTRY_POINT;
TBool continueCommand(EFalse);
TInt command = aCommand.Command();
switch(command)
{
case ECalenNewMeeting:
case ECalenNewDayNote:
{
TUid currentView = iController.ViewManager().CurrentView();
if( KUidCalenTodoView == currentView )
{
// Open NewEntry as "To-Do", if editor is launched from To-Do view.
MCalenContext& context = iController.Services().Context();
// Set the date on the context to today.
TTime homeTime;
homeTime.HomeTime();
TCalTime today;
today.SetTimeLocalL( homeTime );
context.SetFocusDateL( today, TVwsViewId( KUidCalendar, KUidCalenTodoView ) );
EditNewEntryL( CCalEntry::ETodo );
}
else
{
EditNewEntryL();
}
}
break;
case ECalenNewTodo:
EditNewEntryL( CCalEntry::ETodo );
break;
case ECalenNewAnniv:
EditNewEntryL( CCalEntry::EAnniv );
break;
case ECalenNewMeetingRequest:
{
EditNewMeetingRequestL();
}
break;
case ECalenEditCurrentEntry:
case ECalenEditSeries:
case ECalenEditOccurrence:
case ECalenCompleteTodo:
case ECalenRestoreTodo:
case ECalenMarkEntryAsDone:
case ECalenMarkEntryAsUnDone:
{
// These commands need the entry view
// to be constructed before being called
CCalEntryView* entryView = iGlobalData->EntryViewL();
if( !entryView )
{
// Store the command and wait for notification
WaitForEntryViewNotificationL( aCommand );
}
else
{
switch ( command )
{
case ECalenEditCurrentEntry:
{
MCalenContext& context = iGlobalData->Context();
entryView = iGlobalData->EntryViewL(context.InstanceId().iColId);
CCalEntry* entry = entryView->FetchL(
context.InstanceId().iEntryLocalUid );
CleanupStack::PushL( entry );
User::LeaveIfNull( entry );
EditEntryL( entry,
context.InstanceId().iInstanceTime,
MAgnEntryUi::EEditExistingEntry );
CleanupStack::PopAndDestroy( entry );
break;
}
case ECalenCompleteTodo:
SetTodoCompleteL( ETrue );
break;
case ECalenRestoreTodo:
SetTodoCompleteL( EFalse );
break;
case ECalenMarkEntryAsDone:
continueCommand = SetMultipleTodoCompleteL(ETrue );
break;
case ECalenMarkEntryAsUnDone:
continueCommand = SetMultipleTodoCompleteL(EFalse );
break;
default:
{
// Should never reach this point.
ASSERT( EFalse );
}
}
}
}
break;
case ECalenSend:
{
iGlobalData->CalenSendL().DisplaySendCascadeMenuL();
if( iGlobalData->CalenSendL().CanSendL( ECalenSend ) )
{
SendEntryL();
iController.BroadcastNotification( ECalenNotifyEntrySent );
}
// ECalenNotifyDialogClosed issued when Messaging Query is cancelled
// by the user.
else
{
iController.BroadcastNotification( ECalenNotifyEntrySendCancel );
}
}
break;
default:
// Controller decided this class was the place to handle this
// command
break;
}
TRACE_EXIT_POINT;
return continueCommand;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::CalenCommandHandlerExtensionL
// Dummy implementation.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
TAny* CCalenEditUi::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ )
{
TRACE_ENTRY_POINT;
TRACE_EXIT_POINT;
return NULL;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::SetTodoCompleteL
// Completes or restores a todo.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::SetTodoCompleteL( TBool aComplete )
{
TRACE_ENTRY_POINT;
MCalenContext& context = iGlobalData->Context();
ASSERT( !( context.InstanceId() == ( TCalenInstanceId::NullInstanceId() ) ) );
// HandleActionUiCommandL creates the entry view if it has
// not already been created before SetTodoCompleteL is called.
CCalEntryView* entryView = iGlobalData->EntryViewL(context.InstanceId().iColId);
ASSERT( entryView );
CCalEntry* entry = entryView->FetchL( context.InstanceId().iEntryLocalUid );
CleanupStack::PushL( entry );
if( entry )
{
CalenActionUiUtils::SetToDoCompleteStatusL( *entryView, entry, aComplete );
//iContainer->NotifyEntryChangeL( *entry, entry->StartTimeL() );
iController.BroadcastNotification( ECalenNotifyEntrySaved );
}
CleanupStack::PopAndDestroy( entry );
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::SetTodoEntryCompleteL
// Completes or restores a todo.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::SetTodoEntryCompleteL(TBool aComplete,TCalLocalUid aEntryUid,TCalCollectionId colId)
{
TRACE_ENTRY_POINT;
// HandleActionUiCommandL creates the entry view if it has
// not already been created before SetTodoCompleteL is called.
CCalEntryView* entryView = iGlobalData->EntryViewL(colId);
ASSERT( entryView );
CCalEntry* entry = entryView->FetchL( aEntryUid );
CleanupStack::PushL( entry );
if( entry )
{
CalenActionUiUtils::SetToDoCompleteStatusL( *entryView, entry, aComplete );
}
CleanupStack::PopAndDestroy( entry );
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::EditNewEntryL
// Creates a new entry and opens it for editing
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::EditNewEntryL( CCalEntry::TType aEntryType)
{
TRACE_ENTRY_POINT;
// Create unique ID.
HBufC8* guid = iGlobalData->InterimUtilsL().GlobalUidL();
CleanupStack::PushL( guid );
CCalEntry* entry = CCalEntry::NewL( aEntryType, guid, CCalEntry::EMethodNone, 0 );
CleanupStack::Pop( guid );
CleanupStack::PushL( entry );
// Set initial start and end times from Calendar context
TTime focusedTime = CalculateActiveTimeFromContextL();
TCalTime initialCalTime;
initialCalTime.SetTimeLocalL( focusedTime );
entry->SetStartAndEndTimeL( initialCalTime, initialCalTime );
if( entry->EntryTypeL()==CCalEntry::EAnniv )
{
TCalRRule rrule( TCalRRule::EYearly );
TCalTime startDate;
rrule.SetDtStart( initialCalTime );
rrule.SetInterval( 1 ); // once a year
entry->SetRRuleL( rrule );
}
MCalenContext& context = iGlobalData->Context();
TCalCollectionId colId = context.InstanceId().iColId;
TCalenInstanceId id = TCalenInstanceId::CreateL( *entry, initialCalTime );
id.iColId = colId;
context.SetInstanceIdL( id, context.ViewId() );
TTime instanceTime = entry->StartTimeL().TimeLocalL();
EditEntryL( entry, instanceTime, MAgnEntryUi::ECreateNewEntry );
CleanupStack::PopAndDestroy( entry );
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::EditNewMeetingRequestL
// Creates a new meeting request and opens it for editing
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::EditNewMeetingRequestL()
{
TRACE_ENTRY_POINT;
CMRMailboxUtils::TMailboxInfo defaultMailBox;
if( !iGlobalData->AttemptToRetrieveDefaultMailboxL( defaultMailBox ) )
{
// User either doesn't have any mailboxes or didn't select a default mailbox.
// Don't create the meeting request.
TRACE_EXIT_POINT;
return;
}
// If we got this far, defaultMailBox should be initialised.
HBufC8* guid = iGlobalData->InterimUtilsL().GlobalUidL();
CleanupStack::PushL( guid );
CCalEntry* entry = CCalEntry::NewL( CCalEntry::EAppt,
guid,
CCalEntry::EMethodRequest,
0 );
CleanupStack::Pop( guid );
CleanupStack::PushL( entry );
// Set initial start and end times from Active Calendar Context
TTime focusedTime = iGlobalData->Context().FocusDateAndTimeL().TimeLocalL();
TCalTime initialCalTime;
// No need to handle floating time check here, as meetings are
// always fixed.
initialCalTime.SetTimeLocalL( focusedTime );
entry->SetStartAndEndTimeL( initialCalTime, initialCalTime );
//Set the organizer from the selected mailbox
CCalUser* organizer = CCalUser::NewL( defaultMailBox.iEmailAddress );
entry->SetOrganizerL( organizer );
TTime instanceTime = entry->StartTimeL().TimeLocalL();
EditEntryL( entry, instanceTime, MAgnEntryUi::ECreateNewEntry );
CleanupStack::PopAndDestroy( entry );
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::EditEntryL
// Opens the entry aEntry for editing
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::EditEntryL( CCalEntry* aEntry,
const TTime& aInstanceDate,
MAgnEntryUi::TAgnEntryUiEditorMode aEditorMode )
{
TRACE_ENTRY_POINT;
// Set the flag
isEditorActive = ETrue;
if( !iEditorsPlugin )
{
//Only created on first use
LoadEditorsPluginL();
if( !iEditorsPlugin )
{
// User was prompted to set a default mailbox and hit cancel
// Entry will not be opened
TRACE_EXIT_POINT;
return;
}
}
MAgnEntryUi::TAgnEntryUiInParams inParams( KUidCalendar,
iGlobalData->CalSessionL(),
aEditorMode );
// Use floating time for non-timed entries
if( !CalenAgendaUtils::IsTimedEntryL(aEntry->EntryTypeL()) )
{
inParams.iInstanceDate.SetTimeLocalFloatingL( aInstanceDate );
}
else
{
inParams.iInstanceDate.SetTimeLocalL( aInstanceDate );
}
inParams.iMsgSession = NULL;
MAgnEntryUi::TAgnEntryUiOutParams outParams;
// Launch Entry UI
RPointerArray<CCalEntry> entries;
CleanupClosePushL( entries );
entries.AppendL( aEntry ); // aEntry already in cleanup stack -> safe
// Editors need a services implementation.
MCalenServices* svc = CCalenServicesImpl::NewL();
CleanupReleasePushL( *svc );
inParams.iSpare = ( TInt )svc;
// Stop the population of the current view
iController.ViewManager().InterruptPopulationL();
// hide the toolbar
MCalenToolbar* toolbar = iController.Services().ToolbarOrNull();
if(toolbar)
{
toolbar->SetToolbarVisibilityL(EFalse);
}
// If a menubar is active,stop displaying it before launching editor
TUid viewUid = iController.ViewManager().CurrentView();
CEikMenuBar* menuBar = iController.AppUi().View(viewUid)->MenuBar();
if(menuBar)
{
menuBar->StopDisplayingMenuBar();
}
// Launch the viewer / editor plugin
iEditorsPlugin->ExecuteViewL( entries, inParams, outParams, *this );
// Reset the flag
isEditorActive = EFalse;
// Unhide the toolbar when settings is closed
TUid activeViewUid = iController.ViewManager().CurrentView();
if(toolbar && (activeViewUid != KUidCalenMissedAlarmsView ) &&(activeViewUid != KUidCalenMissedEventView ) )
{
toolbar->SetToolbarVisibilityL(ETrue);
}
CleanupStack::PopAndDestroy( svc );
// Close the entries array
CleanupStack::PopAndDestroy( &entries );
switch( outParams.iAction )
{
case MAgnEntryUi::EMeetingSaved:
case MAgnEntryUi::EInstanceRescheduled:
{
// Update context and issue notification before confirmation dialog
// to avoid delay of updating title pane
MCalenContext& context = iGlobalData->Context();
TCalCollectionId colId = context.InstanceId().iColId;
TCalenInstanceId id = TCalenInstanceId::CreateL( TCalLocalUid(
outParams.iSpare),
outParams.iNewInstanceDate.TimeLocalL(), EFalse );
id.iColId = colId;
id.iType = context.InstanceId().iType;
if( aEditorMode != MAgnEntryUi::ECreateNewEntry )
{
id.iInstanceTime = context.InstanceId().iInstanceTime;
}
context.SetInstanceIdL( id, context.ViewId() );
iController.BroadcastNotification( ECalenNotifyEntrySaved );
if( aEditorMode == MAgnEntryUi::ECreateNewEntry )
{
// Show saved note for new entries
TInt res;
if( context.InstanceId().iType == CCalEntry::ETodo )
{
res = R_QTN_CALE_NOTE_TODO_SAVED;
}
else
{
res = R_TEXT_CALENDAR_NOTE_SAVED;
}
HBufC* prompt = StringLoader::LoadLC( res, CEikonEnv::Static() );
CAknConfirmationNote* dialog = new( ELeave )CAknConfirmationNote();
dialog->ExecuteLD( *prompt );
CleanupStack::PopAndDestroy( prompt );
}
}
break;
case MAgnEntryUi::EMeetingDeleted:
iController.BroadcastNotification( ECalenNotifyEntryDeleted );
break;
case MAgnEntryUi::EInstanceDeleted:
iController.BroadcastNotification( ECalenNotifyInstanceDeleted );
break;
case MAgnEntryUi::ENoAction:
default:
iController.BroadcastNotification( ECalenNotifyEntrySaved );
break;
}
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::LoadEditorsPluginL
// Attempts to load the editors plugin into iEditorsPlugin. If failure occurs
// (for example, if the user is prompted to select a default mailbox and hits
// cancel), iEditorsPlugin is set to NULL.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::LoadEditorsPluginL()
{
TRACE_ENTRY_POINT;
delete iEditorsPlugin;
iEditorsPlugin = NULL;
if( iGlobalData->InterimUtilsL().MRViewersEnabledL() )
{
//Get the currently selected mailbox
CMRMailboxUtils::TMailboxInfo defaultMailBox;
if( iGlobalData->AttemptToRetrieveDefaultMailboxL( defaultMailBox ) )
{
//CAgnEntryUi resolves Meeting request viewer based on mtm uid
TBuf8<KMaxUidName> mrMtm;
CnvUtfConverter::ConvertFromUnicodeToUtf8( mrMtm,
defaultMailBox.iMtmUid.Name() );
iEditorsPlugin = CAgnEntryUi::NewL( mrMtm );
}
}
else
{
iEditorsPlugin = CCalenEditorsPlugin::NewL();
}
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::SendEntryL
// Sends the current entry.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::SendEntryL()
{
TRACE_ENTRY_POINT;
MCalenContext& context = iGlobalData->Context();
ASSERT( !( context.InstanceId() == TCalenInstanceId::NullInstanceId() ) );
//If todo, use the LUid.
//Todos returns the current time if start or end time has not been saved.
if( CCalEntry::ETodo == context.InstanceId().iType )
{
CCalEntry* entry = iGlobalData->EntryViewL(context.InstanceId().iColId)->FetchL(
context.InstanceId().iEntryLocalUid );
if( entry )
{
CleanupStack::PushL( entry );
iGlobalData->CalenSendL().SendAsVCalendarL( ECalenSend, *entry );
CleanupStack::PopAndDestroy( entry );
}
}
else // Not todo
{
RArray<TInt> colIdArray;
CleanupClosePushL(colIdArray);
iController.GetActiveCollectionidsL(colIdArray);
CCalInstance* instance = CalenActionUiUtils::FindPossibleInstanceL(
context.InstanceId(),
*iGlobalData->InstanceViewL(colIdArray) );
CleanupStack::PushL( instance );
if( instance )
{
CCalEntry& entry = instance->Entry();
iGlobalData->CalenSendL().SendAsVCalendarL( ECalenSend, entry );
}
CleanupStack::PopAndDestroy( instance );
CleanupStack::PopAndDestroy(&colIdArray);
}
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::ProcessCommandWithResultL
// This is pure virtual from MAgnEntryUiCallback. We don't use it.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
TInt CCalenEditUi::ProcessCommandWithResultL( TInt /*aCommandId*/ )
{
TRACE_ENTRY_POINT;
TRACE_EXIT_POINT;
return KErrNone;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::ProcessCommandL
// This is pure virtual from MAgnEntryUiCallback. We don't use it.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::ProcessCommandL( TInt /*aCommandId*/ )
{
TRACE_ENTRY_POINT;
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::WaitForEntryViewNotificationL
// Register for view created notification
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::WaitForEntryViewNotificationL( const TCalenCommand& aCommand )
{
TRACE_ENTRY_POINT;
iStoredCommand = aCommand;
// Only wait for an entry view if it doesn't already exist
ASSERT( !( iGlobalData->EntryViewL() ) );
// Register for notifications
iController.RegisterForNotificationsL( this, ECalenNotifyEntryInstanceViewCreated );
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::HandleECalenNotifyViewCreatedL
// Handle ECalenNotifyViewCreated
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::HandleECalenNotifyViewCreatedL()
{
TRACE_ENTRY_POINT;
if( iGlobalData->EntryViewL() )
{
// Handle the outstanding command
HandleCommandL( iStoredCommand );
// Cancel the notify as the entry view is now
// constructed.
iController.CancelNotifications( this );
}
TRACE_EXIT_POINT;
}
// ----------------------------------------------------------------------------
// CCalenEditUi::HandleNotification
// Handle notifications
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CCalenEditUi::HandleNotification(const TCalenNotification aNotification )
{
TRACE_ENTRY_POINT;
if ( aNotification == ECalenNotifyEntryInstanceViewCreated )
{
PIM_TRAPD_HANDLE( HandleECalenNotifyViewCreatedL() );
}
if( aNotification == ECalenNotifyCancelStatusUpdation)
{
if(iMutlipleContextIdsCount)
{
// get the context
MCalenContext& context = iGlobalData->Context();
// reset the multiple contexts
context.ResetMultipleContextIds();
// dismiss the waitdialog
if(iWaitDialog)
{
TRAP_IGNORE(iWaitDialog->ProcessFinishedL());
}
}
}
TRACE_EXIT_POINT;
}
TBool CCalenEditUi::SetMultipleTodoCompleteL(TBool aComplete )
{
TRACE_ENTRY_POINT;
TBool continueCommand(EFalse);
// get the context
MCalenContext& context = iGlobalData->Context();
// get the multliple context ids count
iMutlipleContextIdsCount = context.MutlipleContextIdsCount();
ASSERT( iMutlipleContextIdsCount );
if(!iMoreEntriesToComplete)
{
DisplayWaitDialogL();
}
// get the multiple context instance ids
RArray<TCalenInstanceId>& multipleContextIds = context.GetMutlipleContextIds();
if(iMutlipleContextIdsCount <= iEntriesToComplete )
{
iMoreEntriesToComplete = EFalse;
iEntriesToComplete = iMutlipleContextIdsCount;
}
else
{
iMoreEntriesToComplete = ETrue;
// set the continue command flag if more entries are there to delete
continueCommand = ETrue;
}
TInt index(0);
while(index<iEntriesToComplete)
{
// get the local uid of the entry through multiple context list
TCalLocalUid entryLocalUid = multipleContextIds[0].iEntryLocalUid;
TCalCollectionId colId = multipleContextIds[0].iColId;
if(entryLocalUid)
{
SetTodoEntryCompleteL(aComplete, entryLocalUid,colId);
}
// remove mutliple context based on the instanceid
context.RemoveMultipleContextId(multipleContextIds[0]);
index++;
}
if(!iMoreEntriesToComplete)
{
MarkedEntriesCompletedL();
}
TRACE_EXIT_POINT;
return continueCommand;
}
// -----------------------------------------------------------------------------
// CCalenEditUi::DisplayWaitDialogL
// Display wait dialog
// -----------------------------------------------------------------------------
//
void CCalenEditUi::DisplayWaitDialogL()
{
TRACE_ENTRY_POINT;
delete iWaitDialog;
iWaitDialog = NULL;
iWaitDialog = new( ELeave )CAknWaitDialog( REINTERPRET_CAST( CEikDialog**, &iWaitDialog ), ETrue );
iWaitDialog->ExecuteLD( R_TODO_UPDATING_STATUS_NOTE );
iWaitDialog->SetCallback(this);
TRACE_EXIT_POINT;
}
// -----------------------------------------------------------------------------
// CCalenEditUi::MarkedEntriesDeletedL
// Dismiss wait dialog and show information note
// -----------------------------------------------------------------------------
//
void CCalenEditUi::MarkedEntriesCompletedL()
{
TRACE_ENTRY_POINT;
// dismiss the waitdialog
if(iWaitDialog)
{
iWaitDialog->ProcessFinishedL();
}
if(iMutlipleContextIdsCount)
{
// get the context
MCalenContext& context = iGlobalData->Context();
// reset the multiple contexts
context.ResetMultipleContextIds();
}
// notify marked entries deleted
iController.BroadcastNotification( ECalenNotifyMarkedEntryCompleted );
TRACE_EXIT_POINT;
}
void CCalenEditUi::DialogDismissedL( const TInt /*aButtonId*/ )
{
TRACE_ENTRY_POINT;
// no more entries to delete
iMoreEntriesToComplete = EFalse;
// issue notification cancel delete
// iController.BroadcastNotification(ECalenNotifyCancelStatusUpdation);
TRACE_EXIT_POINT;
}
// -----------------------------------------------------------------------------
// CCalenEditUi::CalculateActiveTimeFromContextL
// CCalculate active time from context
// -----------------------------------------------------------------------------
//
TTime CCalenEditUi::CalculateActiveTimeFromContextL()
{
TRACE_ENTRY_POINT;
// The active time is calculated based on the following table
// Current View
// Month Day Week ToDo
// Meeting* CFD (@8am) CFD (@8am) CFD @ FCT Today (@8am)
// Day Note CFD CFD CFD Today
// Anniv* CFD CFD CFD Today
// ToDo* CFD CFD CFD Today
// CFD = Currently Focused Date, the one shown in Navigator toolbar
// FCT = Focused Cell's Time, applicable only to Week View
// (*) Alarm Default times are also set using the values
TTime activeTime(Time::NullTTime()); // initialize with NULL time
TTime& activeTimeRef = activeTime;
MCalenContext &context = iGlobalData->Context();
TUid currentView = iController.ViewManager().CurrentView();
if(currentView == KUidCalenWeekView)
{
// use CFD
activeTime = CalenDateUtils::BeginningOfDay(
context.FocusDateAndTimeL().TimeLocalL()); // CFD
// CFD @ FCT
// focus on empty nontimed cell
if( context.FocusDateAndTimeL().TimeUtcL() == Time::NullTTime() )
{
activeTime = CalenDateUtils::DefaultTime( activeTimeRef );
}
else if(context.InstanceId().iType != CCalEntry::EAppt)
{
activeTime = CalenDateUtils::DefaultTime( activeTimeRef );
}
else
{
activeTime += CalenDateUtils::TimeOfDay(
context.FocusDateAndTimeL().TimeLocalL().DateTime() );
}
}
else
{
// use Today @ 8 am
activeTime = CalenDateUtils::Today();
activeTime = CalenDateUtils::DefaultTime(context.FocusDateAndTimeL().TimeLocalL()); // 8 am
}
TRACE_EXIT_POINT;
return activeTime;
}
// -----------------------------------------------------------------------------
// CCalenEditUi::IsEditorActive
// Tells framework whether editor is active or not
// -----------------------------------------------------------------------------
//
TBool CCalenEditUi::IsEditorActive()
{
return isEditorActive;
}
// End of file