diff -r f979ecb2b13e -r c198609911f9 calendarui/controller/src/calendeleteui.cpp --- a/calendarui/controller/src/calendeleteui.cpp Tue Feb 02 10:12:19 2010 +0200 +++ b/calendarui/controller/src/calendeleteui.cpp Fri Apr 16 14:57:40 2010 +0300 @@ -1,5 +1,5 @@ /* -* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). * All rights reserved. * This component and the accompanying materials are made available * under the terms of "Eclipse Public License v1.0" @@ -15,53 +15,45 @@ * */ - -// INCLUDES -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +// System includes +#include +#include +#include +#include +#include +#include +#include #include -#include -#include -#include -#include -#include -#include -#include // Calendar commands -#include -#include // TCalenInstanceId -#include -#include +#include -#include "calendarui_debug.h" // Debug +// User includes +#include "calendarui_debug.h" #include "calendeleteui.h" +#include "hb_calencommands.hrh" +#include "calencontext.h" #include "calencontroller.h" #include "CleanupResetAndDestroy.h" -#include "CalenInterimUtils2.h" -#include "CalendarPrivateCRKeys.h" // For CalendarInternalCRKeys.h -#include "calenmultipledbmanager.h" +#include "caleninstanceid.h" +#include "calenactionuiutils.h" +#include "CalendarPrivateCRKeys.h" // includes CalendarInternalCRKeys.h +#include "calendateutils.h" +#include "calenagendautils.h" + // Local constants const TInt KEntriesToDelete = 1; // ---------------------------------------------------------------------------- -// CCalenDeleteUi::NewL +// CalenDeleteUi::NewL // Two phased constructor // (other items were commented in a header). // ---------------------------------------------------------------------------- // -CCalenDeleteUi* CCalenDeleteUi::NewL( CCalenController& aController ) +CalenDeleteUi* CalenDeleteUi::NewL( CCalenController& aController ) { TRACE_ENTRY_POINT; - CCalenDeleteUi* self = new( ELeave ) CCalenDeleteUi( aController ); + CalenDeleteUi* self = new( ELeave ) CalenDeleteUi( aController, NULL ); CleanupStack::PushL( self ); self->ConstructL(); CleanupStack::Pop( self ); @@ -71,245 +63,144 @@ } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::CCalenDeleteUi +// CalenDeleteUi::CalenDeleteUi // ?implementation_description // (other items were commented in a header). // ---------------------------------------------------------------------------- // -CCalenDeleteUi::CCalenDeleteUi( CCalenController& aController ) - : iEikEnv( CEikonEnv::Static() ), iController( aController ) +CalenDeleteUi::CalenDeleteUi( CCalenController& aController, QObject *parent ) + :QObject(parent), iController( aController ) { TRACE_ENTRY_POINT; + iIsDeleting = false; TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::~CCalenDeleteUi +// CalenDeleteUi::~CalenDeleteUi // Destructor // (other items were commented in a header). // ---------------------------------------------------------------------------- // -CCalenDeleteUi::~CCalenDeleteUi() +CalenDeleteUi::~CalenDeleteUi() { TRACE_ENTRY_POINT; - if( iWaitDialog ) - { - delete iWaitDialog; - iWaitDialog = NULL; - } - - if( iGlobalData ) - { - iGlobalData->Release(); - } - - if( iDelAllRange ) - delete iDelAllRange; - - iDeleteColIds.Reset(); - TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::ConstructL +// CalenDeleteUi::ConstructL // Second phase of construction // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CCalenDeleteUi::ConstructL() +void CalenDeleteUi::ConstructL() { TRACE_ENTRY_POINT; - - iGlobalData = CCalenGlobalData::InstanceL(); - - // Both the entry view and instance views are needed - // by the deleteUi commands, there queue the construction of both - RArray colArray; - iController.GetActiveCollectionidsL(colArray); - - CCalInstanceView* instanceView = iGlobalData->InstanceViewL(colArray); - colArray.Reset(); - if( !instanceView ) - { - iController.RegisterForNotificationsL( this, ECalenNotifyEntryInstanceViewCreated ); - } iController.RegisterForNotificationsL( this, ECalenNotifyCancelDelete ); iMoreEntriesToDelete = EFalse; iDisplayQuery = EFalse; iEntriesToDelete = KEntriesToDelete; - iDelAllRange = NULL; TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::HandleECalenNotifyViewCreatedL -// Handles ECalenNotifyViewCreated. -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -void CCalenDeleteUi::HandleECalenNotifyViewCreatedL() - { - TRACE_ENTRY_POINT; - RArray colArray; - iController.GetActiveCollectionidsL(colArray); - - if( iGlobalData->InstanceViewL(colArray) ) - { - // Handle the outstanding command - HandleCommandL( iStoredCommand ); - - // Cancel the notify as the entry view is now - // constructed. - iController.CancelNotifications( this ); - } - colArray.Reset(); - TRACE_EXIT_POINT; - } - -// ---------------------------------------------------------------------------- -// CCalenDeleteUi::HandleNotification +// CalenDeleteUi::HandleNotification // Handles notifications. // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CCalenDeleteUi::HandleNotification(const TCalenNotification aNotification ) +void CalenDeleteUi::HandleNotification(const TCalenNotification aNotification ) { TRACE_ENTRY_POINT; - if ( aNotification == ECalenNotifyEntryInstanceViewCreated ) - { - PIM_TRAPD_HANDLE( HandleECalenNotifyViewCreatedL() ); - } if( aNotification == ECalenNotifyCancelDelete) { if(iMutlipleContextIdsCount) { // get the context - MCalenContext& context = iGlobalData->Context(); + MCalenContext& context = iController.context(); // reset the multiple contexts - context.ResetMultipleContextIds(); - - // dismiss the waitdialog - if(iWaitDialog) - { - TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); - } + context.resetMultipleContextIds(); + } } TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::HandleCommandL +// CalenDeleteUi::HandleCommandL // Handles action ui commands // (other items were commented in a header). // ---------------------------------------------------------------------------- // -TBool CCalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand ) +TBool CalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand ) { TRACE_ENTRY_POINT; TBool continueCommand(EFalse); - - RArray colArray; - iController.GetActiveCollectionidsL(colArray); - - if( colArray.Count() && !( iGlobalData->InstanceViewL(colArray) ) ) + + switch( aCommand.Command() ) { - iStoredCommand = aCommand; - } - else - { - switch( aCommand.Command() ) - { - case ECalenDeleteCurrentEntry: - DeleteCurrentEntryL(); // Entry & instance - break; + case ECalenDeleteCurrentEntry: + + DeleteCurrentEntryL(); // Entry & instance + break; - case ECalenDeleteSeries: - DeleteThisOrAllL( CalCommon::EThisAndAll ); - break; - - case ECalenDeleteCurrentOccurrence: - DeleteThisOrAllL( CalCommon::EThisOnly ); - break; - - case ECalenDeleteEntryWithoutQuery: - continueCommand = DeleteEntryWithoutQueryL(); - break; + case ECalenDeleteSeries: + DeleteThisOrAllL( AgendaUtil::ThisAndAll ); + break; + + case ECalenDeleteCurrentOccurrence: + DeleteThisOrAllL( AgendaUtil::ThisOnly ); + break; + + case ECalenDeleteEntryWithoutQuery: + continueCommand = DeleteEntryWithoutQueryL(); + break; - case ECalenDeleteAllEntries: - HandleDeleteAllEntriesL(); - break; + case ECalenDeleteAllEntries: + DeleteAllEntriesL(); // EntryView & instance + break; - case ECalenDeleteEntriesBeforeDate: - DeleteEntriesBeforeDateL(); // EntryView & instance - break; + case ECalenDeleteEntriesBeforeDate: + DeleteEntriesBeforeDateL(); // EntryView & instance + break; - default: - // Controller decided this class was the place to handle this - // command but it wasn't in our list; something has gone wrong. - //ASSERT( EFalse ); - break; - } + default: + // Controller decided this class was the place to handle this + // command but it wasn't in our list; something has gone wrong. + //ASSERT( EFalse ); + break; } - colArray.Reset(); + TRACE_EXIT_POINT; return continueCommand; } -// ---------------------------------------------------------------------------- -// CCalenDeleteUi::CalenCommandHandlerExtensionL -// Dummy implementation. -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -TAny* CCalenDeleteUi::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ ) - { - TRACE_ENTRY_POINT; - TRACE_EXIT_POINT; - return NULL; - } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteThisOrAllL +// CalenDeleteUi::DeleteThisOrAllL // Deletes series repeating entry // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CCalenDeleteUi::DeleteThisOrAllL( CalCommon::TRecurrenceRange aRepeatType ) +void CalenDeleteUi::DeleteThisOrAllL( AgendaUtil::RecurrenceRange aRepeatType ) { TRACE_ENTRY_POINT; - TBool isDeleted( EFalse ); + bool isDeleted( false ); - RArray colIdArray; - colIdArray.AppendL(iGlobalData->Context().InstanceId().iColId); - - if( iGlobalData->Context().InstanceId().iEntryLocalUid ) + if( iController.context().instanceId().mEntryLocalUid ) { - CCalInstance* instance = - CalenActionUiUtils::FindPossibleInstanceL( - iGlobalData->Context().InstanceId(), - *iGlobalData->InstanceViewL(colIdArray) ); - if( instance ) + AgendaEntry instance = + CalenActionUiUtils::findPossibleInstanceL(iController.context().instanceId(), + iController.Services().agendaInterface() ); + if( !instance.isNull() ) { - CleanupStack::PushL( instance ); isDeleted = DeleteSingleInstanceL( instance, aRepeatType ); - - if( isDeleted ) - { - CleanupStack::Pop( instance ); - } - else - { - CleanupStack::PopAndDestroy( instance ); - } } } - colIdArray.Reset(); - iController.BroadcastNotification( isDeleted? ECalenNotifyEntryDeleted : ECalenNotifyDeleteFailed ); @@ -317,21 +208,21 @@ } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteEntryWithoutQueryL() +// CalenDeleteUi::DeleteEntryWithoutQueryL() // Deletes the current entry // (other items were commented in a header). // ---------------------------------------------------------------------------- // -TBool CCalenDeleteUi::DeleteEntryWithoutQueryL() +TBool CalenDeleteUi::DeleteEntryWithoutQueryL() { TRACE_ENTRY_POINT; - TBool continueCommand(EFalse); + bool continueCommand(EFalse); // get the context - MCalenContext& context = iGlobalData->Context(); + MCalenContext& context = iController.context(); // get the multliple context ids count - iMutlipleContextIdsCount = context.MutlipleContextIdsCount(); + iMutlipleContextIdsCount = context.mutlipleContextIdsCount(); ASSERT( iMutlipleContextIdsCount ); @@ -347,7 +238,7 @@ DisplayWaitDialogL(); } // get the multiple context instance ids - RArray& multipleContextIds = context.GetMutlipleContextIds(); + QList& multipleContextIds = context.getMutlipleContextIds(); if(iMutlipleContextIdsCount <= iEntriesToDelete ) { @@ -365,13 +256,13 @@ while(indexContext().InstanceId().iEntryLocalUid ) - { - //If todo, use the LUid. - //Todos returns the current time if start or end time has not been saved. - if( CCalEntry::ETodo == iGlobalData->Context().InstanceId().iType ) - { - CCalEntry* entry = iGlobalData->EntryViewL(iGlobalData->Context().InstanceId().iColId)->FetchL( - iGlobalData->Context().InstanceId().iEntryLocalUid ); - - if( entry ) - { - CleanupStack::PushL( entry ); - deleted = DeleteEntryL( iGlobalData->EntryViewL(iGlobalData->Context().InstanceId().iColId), entry ); - - if( deleted ) - { - CleanupStack::Pop( entry ); + if (iController.context().instanceId().mEntryLocalUid) { + // Fetch the entry + AgendaEntry entry = iController.Services().agendaInterface()->fetchById( + iController.context().instanceId().mEntryLocalUid); + + // Check if the entry is a To-Do + if (AgendaEntry::TypeTodo == entry.type()) { + if(!entry.isNull()) { + deleted = DeleteEntryL(entry); + if(deleted) { + // Delete is successful notification = ECalenNotifyEntryDeleted; - } - else - { - CleanupStack::PopAndDestroy( entry ); - } } } - else // Not todo - { - RArray colIdArray; - colIdArray.AppendL(iGlobalData->Context().InstanceId().iColId); - - CCalInstance* instance = CalenActionUiUtils::FindPossibleInstanceL( - iGlobalData->Context().InstanceId(), - *iGlobalData->InstanceViewL(colIdArray) ); - // if we have instance we will do delete other wise just return - if( instance ) - { - // Note: ownership handling of instance is dirty in this case, - // because DeleteSingleInstanceLtakes ownership, if it's deletes - // instance (property of CalInterimApi), otherwise not. - CleanupStack::PushL( instance ); - deleted = DeleteSingleInstanceL( instance ); - - if( deleted ) - { - CleanupStack::Pop( instance ); + } + else { + if (entry.isRepeating() || !entry.recurrenceId().isNull()) { + // Show a confirmation note whether the user + // wants to delete the single instance or all of them + showRepeatingEntryDeleteQuery(); + } else { + // If the entry is not a repeating entry, + // delete it directly + deleted = DeleteEntryL(entry); + if (deleted) { + // Delete is successful notification = ECalenNotifyEntryDeleted; - } - else - { - CleanupStack::PopAndDestroy( instance ); - } } - colIdArray.Reset(); } } - else - { - TBool doDelete( ETrue ); - - doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL( - iGlobalData->Context().InstanceId().iType == CCalEntry::ETodo ? - CalenActionUiUtils::EDeleteToDo : - CalenActionUiUtils::EDeleteEntry ); - if ( doDelete ) - { - notification = ECalenNotifyEntryDeleted; - } - } - + } + iController.BroadcastNotification( notification ); TRACE_EXIT_POINT; - } +} // ---------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteAllEntriesL +// CalenDeleteUi::DeleteAllEntriesL // Deletes all entries // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CCalenDeleteUi::DeleteAllEntriesL() +void CalenDeleteUi::DeleteAllEntriesL() { TRACE_ENTRY_POINT; ASSERT( !iIsDeleting ); - const TInt buttonId = CalenActionUiUtils::ShowDeleteConfirmationQueryL( - CalenActionUiUtils::EDeleteAll ); - + const int buttonId = CalenActionUiUtils::showDeleteConfirmationQueryL( + CalenActionUiUtils::EDeleteAll ); if( buttonId ) { - HandleDeleteMultipleEventsL( TCalTime::MinTime(), TCalTime::MaxTime(), - R_QTN_CALE_CONF_ALL_NOTES_DELETED ); + HandleDeleteMultipleEventsL( AgendaUtil::minTime(), AgendaUtil::maxTime(),1 ); } else { @@ -509,312 +361,295 @@ } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteEntriesBeforeDateL +// CalenDeleteUi::DeleteEntriesBeforeDateL // Deletes all entries before a set date. // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CCalenDeleteUi::DeleteEntriesBeforeDateL() +void CalenDeleteUi::DeleteEntriesBeforeDateL() { TRACE_ENTRY_POINT; ASSERT( !iIsDeleting ); - TTime date; - date.HomeTime(); - TTime today = date; - TBool execute( EFalse ); - TBool exit( ETrue ); - do{ - exit = ETrue; - execute = EFalse; + TCalenNotification notification = ECalenNotifyDeleteFailed; + + // launch the datepicker + mIsDateValid = false; + dateQuery(); - TInt buttonId = CalenActionUiUtils::DateQueryL(date, R_CALEN_DEL_BEFORE_DATE_PROMPT); - - if( buttonId == EAknSoftkeyOk || buttonId == EEikBidOk ) + if( mIsDateValid ) + { + // Do delete only if inputted day is after beginning of range + if( mDateTime > AgendaUtil::minTime() ) { - execute = ETrue; - if( today < date ) - { - CAknNoteDialog* dialog = new( ELeave ) CAknNoteDialog( - CAknNoteDialog::EConfirmationTone, - CAknNoteDialog::ELongTimeout ); - dialog->ExecuteLD( R_CALEN_DELETEERROR_NOTE ); - execute = EFalse; - exit = EFalse; - } - } - }while( !exit ); + // Two pass delete: + // 1. pass + // To prevent destroying entries starting and ending midnight + // subtract one microsecond and do delete on that range. + QTime time = mDateTime.time(); + time.setHMS(time.hour(), time.minute(), time.second(), time.msec() - 1); + mDateTime.setTime(time); + mDateTime = ( mDateTime > AgendaUtil::minTime()? mDateTime : AgendaUtil::minTime()); - // Do delete only if inputted day is after beginning of range - if( execute && date > TCalTime::MinTime() ) - { - // Two pass delete: - // 1. pass - // To prevent destroying entries starting and ending midnight - // subtract one microsecond and do delete on that range. - date -= TTimeIntervalMicroSeconds32( 1 ); - date = Max( date, TCalTime::MinTime() ); + HandleDeleteMultipleEventsL( AgendaUtil::minTime(), + mDateTime,1 ); + notification = ECalenNotifyMultipleEntriesDeleted; + } + } - HandleDeleteMultipleEventsL( TCalTime::MinTime(), - date, - R_QTN_CALE_CONF_PAST_NOTE_DELETED ); - } - else - { - iController.BroadcastNotification( ECalenNotifyDeleteFailed ); - } - + iController.BroadcastNotification( notification ); TRACE_EXIT_POINT; } + +void CalenDeleteUi::dateQuery() + { + // Create a popup with datepicker to select the date. + QDateTime currentDateTime(CalenDateUtils::today()); + QDate currentDate(currentDateTime.date()); + mDatePicker = new HbDateTimePicker(currentDate); + mDatePicker->setMinimumDate(CalenDateUtils::minTime().date()); + mDatePicker->setMaximumDate(currentDate); + HbDialog popUp; + popUp.setDismissPolicy(HbDialog::NoDismiss); + popUp.setTimeout(HbDialog::NoTimeout ); + popUp.setHeadingWidget(new HbLabel(hbTrId("txt_calendar_title_set_date"))); + popUp.setContentWidget(mDatePicker); + HbAction *okAction = new HbAction(hbTrId("txt_calendar_button_dialog_delete")); + popUp.setPrimaryAction(okAction); + connect(okAction,SIGNAL(triggered()),this,SLOT(getSelectedDate())); + connect(okAction,SIGNAL(triggered()),&popUp,SLOT(close())); + popUp.setSecondaryAction(new HbAction(hbTrId("txt_common_button_cancel"),&popUp)); + popUp.exec(); + } + +void CalenDeleteUi::showRepeatingEntryDeleteQuery() +{ + HbDialog popUp; + popUp.setDismissPolicy(HbDialog::NoDismiss); + popUp.setTimeout(HbDialog::NoTimeout); + + QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical); + HbWidget *editWidget = new HbWidget(); + editWidget->setLayout(layout); + + HbRadioButtonList *editButtonList = new HbRadioButtonList(); + + QStringList list; + list << hbTrId("txt_calendar_info_this_occurrence_only") + << hbTrId("txt_calendar_info_all_occurences"); + + editButtonList->setItems(list); + + layout->addItem(editButtonList); + + popUp.setContentWidget(editWidget); + popUp.setHeadingWidget(new HbLabel( + hbTrId("txt_calendar_title_delete_repeated_entry"))); + + connect(editButtonList, SIGNAL(itemSelected(int)), this, + SLOT(handleRepeatedEntryDelete(int))); + connect(editButtonList, SIGNAL(itemSelected(int)), &popUp, SLOT(close())); + + // Create secondary action + HbAction *cancelAction = new HbAction( + hbTrId("txt_calendar_button_softkey1_cancel")); + popUp.setSecondaryAction(cancelAction); + connect(cancelAction, SIGNAL(triggered()), this, SLOT(handleCancel())); + connect(cancelAction, SIGNAL(triggered()), &popUp, SLOT(close())); + + // Show the popup + popUp.exec(); +} + +void CalenDeleteUi::getSelectedDate() + { + QDate selectedDate(mDatePicker->date()); + + // Check if the date is within the range. + if(selectedDate.isValid()) + { + QTime time(0,0,0,0); + mDateTime.setDate(selectedDate); + mDateTime.setTime(time); + mIsDateValid = true; + } + } + +void CalenDeleteUi::handleRepeatedEntryDelete(int index) +{ + // Fetch the entry + // Find all possible instances + AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL( + iController.context().instanceId(), + iController.Services().agendaInterface()); + + if (!instance.isNull()) { + connect(iController.Services().agendaInterface(), SIGNAL(entryDeleted(ulong)), + this, SLOT(entryDeleted(ulong))); + switch(index) { + case 0: + // User wants to delete only this occurence + iController.Services().agendaInterface()->deleteRepeatedEntry(instance, AgendaUtil::ThisOnly); + break; + case 1: + // User wants to delete all the occurences + iController.Services().agendaInterface()->deleteRepeatedEntry(instance, AgendaUtil::ThisAndAll); + break; + } + } +} + +void CalenDeleteUi::entryDeleted(ulong id) +{ + if (iController.context().instanceId().mEntryLocalUid == id) { + iController.BroadcastNotification(ECalenNotifyEntryDeleted); + } + disconnect(iController.Services().agendaInterface(), SIGNAL(entryDeleted(ulong)), + this, SLOT(entryDeleted(ulong))); +} // ---------------------------------------------------------------------------- -// CCalenDeleteUi::HandleDeleteMultipleEventsL +// CalenDeleteUi::HandleDeleteMultipleEventsL // Handles multiple delete events // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CCalenDeleteUi::HandleDeleteMultipleEventsL( const TTime& aFirstDay, - const TTime& aLastDay, - TInt aConfNoteId ) +void CalenDeleteUi::HandleDeleteMultipleEventsL( const QDateTime& aFirstDay, + const QDateTime& aLastDay, + int aConfNoteId ) { TRACE_ENTRY_POINT; - ASSERT( !iWaitDialog ); + ASSERT( !iIsDeleting ); iConfirmationNoteId = aConfNoteId; - - iWaitDialog = new( ELeave ) CAknWaitDialog( REINTERPRET_CAST( CEikDialog**, - &iWaitDialog ) ); - iWaitDialog->ExecuteLD( R_CALEN_DELETE_WAIT_NOTE ); - + DeleteDayRangeL( aFirstDay, aLastDay ); TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteDayRangeL +// CalenDeleteUi::DeleteDayRangeL // Deletes all entries in a given range. // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CCalenDeleteUi::DeleteDayRangeL( const TTime& aStart, - const TTime& aEnd ) +void CalenDeleteUi::DeleteDayRangeL( const QDateTime& aStart, + const QDateTime& aEnd ) { TRACE_ENTRY_POINT; iStartTime = aStart; iEndTime = aEnd; - - TCalTime start, end; - start.SetTimeLocalL( iStartTime ); - end.SetTimeLocalL( iEndTime ); - - if( iDelAllRange ) - { - delete iDelAllRange; - iDelAllRange = NULL; - } + + iIsDeleting = ETrue; - iDelAllRange = new(ELeave) CalCommon::TCalTimeRange( start, end ); - iDeleteColIds.Reset(); - - iIsDeleting = ETrue; + //AgendaUtil& agendaInterface = iController.agendaInterface(); + // Connect to the signal that gets generated when deletion is completed + connect(iController.agendaInterface(), SIGNAL(entriesDeleted(int)), this, + SLOT(doCompleted(int))); + // 1: First pass, delete all entries. + iController.agendaInterface()->deleteEntries(iStartTime, iEndTime); - iController.GetActiveCollectionidsL(iDeleteColIds); - - //remember the calenders, delete entries in each calendar one by one by calling DeleteL(...) after completed() - iNumberOfCalendars = iDeleteColIds.Count(); - iToShowDeleteNote = 0; - iGlobalData->EntryViewL(iDeleteColIds[iToShowDeleteNote])->DeleteL( *iDelAllRange, CalCommon::EIncludeAll, *this ); - TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::Completed -// Completed callback +// CalenDeleteUi::DoCompletedL +// Handles delete callback // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CCalenDeleteUi::Completed( TInt aFirstPassError ) +void CalenDeleteUi::doCompleted( int aFirstPassError ) { TRACE_ENTRY_POINT; - PIM_TRAPD_HANDLE( DoCompletedL( aFirstPassError ) ); + if( aFirstPassError == KErrNone ) + { + // 2: Second pass, delete notes that end 00:00 of next day of iEndTime + // We didn't delete them in first pass + QDateTime nextMidnight = CalenDateUtils::beginningOfDay( iEndTime.addDays(1) ); + nextMidnight = ( nextMidnight < AgendaUtil::maxTime()? nextMidnight : AgendaUtil::maxTime() ); + PIM_TRAPD_HANDLE( deleteEntriesEndingAtMidnight( nextMidnight ) ); + } + + // 3. End deleting, close wait dialog, and show confirmation or error note + iIsDeleting = EFalse; + + iController.BroadcastNotification( ECalenNotifyMultipleEntriesDeleted ); TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CCalenDeleteUi::DoCompletedL -// Handles delete callback +// CalenDeleteUi::DeleteEntriesEndingAtMidnightL +// Deletes entries ending at midnight on the given day // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CCalenDeleteUi::DoCompletedL( TInt aFirstPassError ) +void CalenDeleteUi::deleteEntriesEndingAtMidnight( QDateTime aMidnight ) { TRACE_ENTRY_POINT; - iToShowDeleteNote++; - if(iNumberOfCalendars == iToShowDeleteNote) - { - if( aFirstPassError == KErrNone ) - { - // 2: Second pass, delete notes that end 00:00 of next day of iEndTime - // We didn't delete them in first pass - TTime nextMidnight = CalenDateUtils::BeginningOfDay( iEndTime + TTimeIntervalDays( 1 ) ); - nextMidnight = Min( nextMidnight, TCalTime::MaxTime() ); - PIM_TRAPD_HANDLE( DeleteEntriesEndingAtMidnightL( nextMidnight ) ); - } - - // 3. End deleting, close wait dialog, and show confirmation or error note - iIsDeleting = EFalse; - iToShowDeleteNote = 0; - // dismiss the waitdialog - if(iWaitDialog) - { - TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); - } + + QDateTime start, end; + QTime startTime(aMidnight.time()); + startTime.setHMS(startTime.hour(), startTime.minute() - 1, + startTime.second(), startTime.msec()); + start.setDate(aMidnight.date()); + start.setTime(startTime); + + end = aMidnight; + + QList instances = iController.Services().agendaInterface()->fetchEntriesInRange( start, end ); - if( aFirstPassError == KErrNone ) - { - // Show confirmation note - HBufC* buf = StringLoader::LoadLC( iConfirmationNoteId, iEikEnv ); - CAknConfirmationNote* dialog = new( ELeave ) CAknConfirmationNote(); - dialog->ExecuteLD(*buf); - CleanupStack::PopAndDestroy( buf ); - } - else - { - // Show error note - if(iEikEnv) - { - iEikEnv->ResolveError( aFirstPassError ); - } - } - iDeleteColIds.Reset(); - delete iDelAllRange; - iDelAllRange = NULL; - - iController.BroadcastNotification( ECalenNotifyMultipleEntriesDeleted ); - } - else + // 2. loop through them and delete those entries that end at midnight + for( int i=0; i < instances.count(); ++i ) { - //delete entries in next calendar... - iGlobalData->EntryViewL(iDeleteColIds[iToShowDeleteNote])->DeleteL( *iDelAllRange, CalCommon::EIncludeAll, *this ); + AgendaEntry entry = instances[i]; + + // Checking that if entry ends at midnight, is quite clumsy, but here goes: + // EndsAtStartOfDay takes only CCalInstance, but here we mimic EndsAtStartOfDay + // for CCalEntry type. + + // First check that if _instance_ ends at midnight, but starts earlier + if( CalenAgendaUtils::endsAtStartOfDayL( entry, aMidnight ) ) + { + // Second, check that _entry's_ endtime is exactly the midnight + // This prevents us from destroying repeating entries, that has one + // instance falling on given midnight. + if( entry.endTime() == aMidnight ) + { + iController.Services().agendaInterface()->deleteRepeatedEntry(entry, AgendaUtil::ThisAndAll); + } + } } TRACE_EXIT_POINT; } -// ---------------------------------------------------------------------------- -// CCalenDeleteUi::NotifyProgress -// Delete progress notification -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -TBool CCalenDeleteUi::NotifyProgress() - { - TRACE_ENTRY_POINT; - // Tell framework that we are not intrested in Progress notifications. - TRACE_EXIT_POINT; - return EFalse; - } - -// ---------------------------------------------------------------------------- -// CCalenDeleteUi::Progress -// Delete progress notification -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -void CCalenDeleteUi::Progress( TInt /*aPercentageCompleted*/ ) - { - TRACE_ENTRY_POINT; - // do nothing, we are not intrested in Progress notifications - TRACE_EXIT_POINT; - } - -// ---------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteEntriesEndingAtMidnightL -// Deletes entries ending at midnight on the given day -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -void CCalenDeleteUi::DeleteEntriesEndingAtMidnightL( TTime aMidnight ) - { - TRACE_ENTRY_POINT; - - TCalTime start, end; - start.SetTimeLocalL( aMidnight - TTimeIntervalMinutes(1) ); - end.SetTimeLocalL( aMidnight ); - CalCommon::TCalTimeRange midnightRange( start, end ); - - RArray colIdArray; - iController.GetActiveCollectionidsL(colIdArray); - - // 1: Find instances falling on midnight moment - RPointerArray< CCalInstance > instances; - CleanupResetAndDestroyPushL( instances ); - iGlobalData->InstanceViewL(colIdArray)->FindInstanceL( instances, - CalCommon::EIncludeAll, - midnightRange ); - - colIdArray.Reset(); - - // 2. loop through them and delete those entries that end at midnight - for( TInt i=0; i < instances.Count(); ++i ) - { - CCalInstance* item = instances[i]; - RArray colIdArray; - colIdArray.AppendL(item->InstanceIdL().iCollectionId); - - // Checking that if entry ends at midnight, is quite clumsy, but here goes: - // EndsAtStartOfDay takes only CCalInstance, but here we mimic EndsAtStartOfDay - // for CCalEntry type. - - // First check that if _instance_ ends at midnight, but starts earlier - if( CalenAgendaUtils::EndsAtStartOfDayL( item, aMidnight ) ) - { - // Second, check that _entry's_ endtime is exactly the midnight - // This prevents us from destroying repeating entries, that has one - // instance falling on given midnight. - if( item->Entry().EndTimeL().TimeLocalL() == aMidnight ) - { - iGlobalData->InstanceViewL(colIdArray)->DeleteL( item, CalCommon::EThisOnly ); - // Ownership was transferred to DeleteL. - // Put null to array to prevent double-deletion - instances[i] = NULL; - } - } - colIdArray.Reset(); - } - CleanupStack::PopAndDestroy( &instances ); - - TRACE_EXIT_POINT; - } - // ----------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteSingleInstanceL +// CalenDeleteUi::DeleteSingleInstanceL // Delete the given instance. Ask the user whether to delete the series or the instance. // (other items were commented in a header). // ----------------------------------------------------------------------------- // -TBool CCalenDeleteUi::DeleteSingleInstanceL( CCalInstance* aInstance ) +TBool CalenDeleteUi::DeleteSingleInstanceL( AgendaEntry& aInstance ) { TRACE_ENTRY_POINT; TRACE_EXIT_POINT; - return DoDeleteSingleInstanceL( aInstance, EFalse, CalCommon::EThisAndAll ); + return DoDeleteSingleInstanceL( aInstance, EFalse, AgendaUtil::ThisAndAll ); } // ----------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteSingleInstanceL +// CalenDeleteUi::DeleteSingleInstanceL // Delete the given instance. Delete the entry range given by aRepeatType. // (other items were commented in a header). // ----------------------------------------------------------------------------- // -TBool CCalenDeleteUi::DeleteSingleInstanceL( CCalInstance* aInstance, - CalCommon::TRecurrenceRange aRepeatType ) +TBool CalenDeleteUi::DeleteSingleInstanceL( AgendaEntry& aInstance, + AgendaUtil::RecurrenceRange aRepeatType ) { TRACE_ENTRY_POINT; TRACE_EXIT_POINT; @@ -822,7 +657,7 @@ } // ----------------------------------------------------------------------------- -// CCalenDeleteUi::DoDeleteSingleInstanceL +// CalenDeleteUi::DoDeleteSingleInstanceL // Performs the deletion of the instance. If aHasRepeatType is EFalse, the user // is prompted to delete either the instance or the entire series. In this case, // aRepeatType is ignored. If aHasRepeatType is ETrue, aRepeatType determines @@ -830,115 +665,52 @@ // (other items were commented in a header). // ----------------------------------------------------------------------------- // -TBool CCalenDeleteUi::DoDeleteSingleInstanceL( CCalInstance* aInstance, - TBool aHasRepeatType, - CalCommon::TRecurrenceRange aRepeatType ) +TBool CalenDeleteUi::DoDeleteSingleInstanceL( AgendaEntry& aInstance, + bool aHasRepeatType, + AgendaUtil::RecurrenceRange aRepeatType ) { TRACE_ENTRY_POINT; - CCalEntry& entry = aInstance->Entry(); - const CCalEntry::TType entryType = entry.EntryTypeL(); - RArray colIdArray; - colIdArray.AppendL(aInstance->InstanceIdL().iCollectionId); - - - TCalRRule rrule; - - TBool repeating = entry.GetRRuleL( rrule ); + bool repeating = aInstance.isRepeating(); if( !repeating ) { // Even though there is no RRule, the entry might // have a list of rdates. - RArray< TCalTime > rDateArray; - CleanupClosePushL( rDateArray ); - entry.GetRDatesL( rDateArray ); - repeating = ( rDateArray.Count() > 0 ); - CleanupStack::PopAndDestroy(); // rDateArray + QList rDates = aInstance.rDates(); + repeating = ( rDates.count() > 0 ); } - - const TBool child = entry.RecurrenceIdL().TimeUtcL() != Time::NullTTime(); + QDateTime recId = aInstance.recurrenceId().toUTC(); + const bool child = recId.isNull(); if( !aHasRepeatType ) { - aRepeatType = CalCommon::EThisAndAll; + aRepeatType = AgendaUtil::ThisAndAll; } - TBool doDelete( ETrue ); + bool doDelete( ETrue ); - if( !aHasRepeatType && ( child || repeating ) && ( entryType != CCalEntry::EAnniv ) ) + if( !aHasRepeatType && ( child || repeating ) && ( aInstance.type() != AgendaEntry::TypeAnniversary ) ) { - doDelete = CalenActionUiUtils::ShowRepeatTypeQueryL( aRepeatType, - CalenActionUiUtils::EDelete ); + //doDelete = CalenActionUiUtils::ShowRepeatTypeQueryL( aRepeatType, + // CalenActionUiUtils::EDelete ); } else { - doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL( - entryType == CCalEntry::ETodo ? + doDelete = CalenActionUiUtils::showDeleteConfirmationQueryL(aInstance.type() == AgendaEntry::TypeTodo ? CalenActionUiUtils::EDeleteToDo : CalenActionUiUtils::EDeleteEntry ); } if( doDelete ) { - if( !TryDeleteWithMrUtilsL( aInstance, aRepeatType ) ) + if( !child || aRepeatType == AgendaUtil::ThisOnly ) { - if( !child || aRepeatType == CalCommon::EThisOnly ) - { - iGlobalData->InstanceViewL(colIdArray)->DeleteL( aInstance, aRepeatType ); - } - else if( aRepeatType == CalCommon::EThisAndAll ) - { - // Unfortunately we can't pass the existing child instance through to the - // InstanceView DeleteL function because even if we pass in EThisAndAll, it - // only ever deletes the exception. We'll have to fetch the parent then - // delete it via the entry view. - RPointerArray entries; - CleanupResetAndDestroyPushL( entries ); - iGlobalData->EntryViewL(aInstance->InstanceIdL().iCollectionId)->FetchL( aInstance->Entry().UidL(), entries ); - iGlobalData->EntryViewL(aInstance->InstanceIdL().iCollectionId)->DeleteL( *entries[0] ); - CleanupStack::PopAndDestroy( &entries ); - if( aInstance ) - { - delete aInstance; - aInstance = NULL; - } - } - else - { - User::Leave( KErrNotSupported ); - } + iController.Services().agendaInterface()->deleteRepeatedEntry( aInstance, aRepeatType ); } - } - - colIdArray.Reset(); - TRACE_EXIT_POINT; - return doDelete; - } - -// ----------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteEntryL -// Deletes an entry from the database -// (other items were commented in a header). -// ----------------------------------------------------------------------------- -// -TBool CCalenDeleteUi::DeleteEntryL( CCalEntryView* aEntryView, CCalEntry* aEntry ) - { - TRACE_ENTRY_POINT; - const CCalEntry::TType entryType = aEntry->EntryTypeL(); - - TBool doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL( - entryType == CCalEntry::ETodo ? - CalenActionUiUtils::EDeleteToDo : - CalenActionUiUtils::EDeleteEntry ); - if( doDelete ) - { - aEntryView->DeleteL( *aEntry ); - - if( aEntry ) + else if( aRepeatType == AgendaUtil::ThisAndAll ) { - delete aEntry; - aEntry = NULL; + iController.Services().agendaInterface()->deleteRepeatedEntry( aInstance, aRepeatType ); } } @@ -947,53 +719,22 @@ } // ----------------------------------------------------------------------------- -// CCalenDeleteUi::TryDeleteWithMrUtilsL -// Attempt to delete the instance using the Meeting Request utilities, -// if MR viewers is enabled. +// CalenDeleteUi::DeleteEntryL +// Deletes an entry from the database // (other items were commented in a header). // ----------------------------------------------------------------------------- // -TBool CCalenDeleteUi::TryDeleteWithMrUtilsL( CCalInstance* aInstance, - CalCommon::TRecurrenceRange aRepeatType ) +TBool CalenDeleteUi::DeleteEntryL( AgendaEntry& entry ) { TRACE_ENTRY_POINT; + + TBool doDelete = CalenActionUiUtils::showDeleteConfirmationQueryL(entry.type() == AgendaEntry::TypeTodo ? + CalenActionUiUtils::EDeleteToDo : + CalenActionUiUtils::EDeleteEntry ); - TBool doDelete = ETrue; - - if( iGlobalData->InterimUtilsL().MRViewersEnabledL() && - iGlobalData->InterimUtilsL().IsMeetingRequestL(aInstance->Entry())) - + if( doDelete ) { - CMRMailboxUtils::TMailboxInfo info; - if( iGlobalData->AttemptToRetrieveDefaultMailboxL( info ) ) - { - if(aRepeatType == CalCommon::EThisAndAll ) - { - iGlobalData->MeetingRequestUtilsL().DeleteWithUiL( aInstance->Entry(), - info.iEntryId ); - if( aInstance ) - { - delete aInstance; - aInstance = NULL; - } - } - else if( aRepeatType == CalCommon::EThisOnly ) - { - iGlobalData->MeetingRequestUtilsL().DeleteWithUiL( aInstance, info.iEntryId ); - } - else - { - User::Leave( KErrNotSupported ); - } - } - else - { - doDelete = EFalse; - } - } - else - { - doDelete = EFalse; + iController.Services().agendaInterface()->deleteEntry(entry.id()); } TRACE_EXIT_POINT; @@ -1001,59 +742,41 @@ } // ----------------------------------------------------------------------------- -// CCalenDeleteUi::ShowMultipleEntriesDeleteQueryL +// CalenDeleteUi::ShowMultipleEntriesDeleteQueryL // For displaying multiple entries deletion confirmation query // ----------------------------------------------------------------------------- // -TInt CCalenDeleteUi::ShowMultipleEntriesDeleteQueryL(TInt aCount) +TInt CalenDeleteUi::ShowMultipleEntriesDeleteQueryL(int aCount) { TRACE_ENTRY_POINT; - - CAknQueryDialog *dialog = CAknQueryDialog::NewL( ); - CleanupStack::PushL( dialog ); - TInt resID; - HBufC* prompt; if( aCount > 1 ) { - resID = R_CALEN_QTN_TODO_QUEST_DELETE_MARKED_NOTES; - prompt = StringLoader::LoadLC( resID, aCount ); + TRACE_EXIT_POINT; + return CalenActionUiUtils::showDeleteConfirmationQueryL(CalenActionUiUtils::EDeleteToDos, aCount ); } else if( aCount == 1 ) { - resID = R_CALEN_QTN_TODO_QUEST_DELETE_MARKED_NOTE; - prompt = StringLoader::LoadLC( resID ); + TRACE_EXIT_POINT; + return CalenActionUiUtils::showDeleteConfirmationQueryL(CalenActionUiUtils::EDeleteToDo); } else - { - CleanupStack::PopAndDestroy( dialog ); + { TRACE_EXIT_POINT; return 0; //return 0 for other invalid aCount value ( < 0 ) - } - dialog->SetPromptL( *prompt ); - CleanupStack::PopAndDestroy( prompt ); - - CleanupStack::Pop( dialog ); - - TRACE_EXIT_POINT; - return dialog->ExecuteLD( R_CALEN_ERASEQUERY_NOTE ); - + } + } // ----------------------------------------------------------------------------- -// CCalenDeleteUi::DialogDismissedL +// CalenDeleteUi::DialogDismissedL // From MProgressDialogCallback // Callback method // called when a dialog is dismissed. // ----------------------------------------------------------------------------- // -void CCalenDeleteUi::DialogDismissedL( const TInt /*aButtonId*/ ) +void CalenDeleteUi::DialogDismissedL( const TInt /*aButtonId*/ ) { TRACE_ENTRY_POINT; - // dismiss the wait dialog - if(iWaitDialog) - { - iWaitDialog->ProcessFinishedL(); - } // no more entries to delete iMoreEntriesToDelete = EFalse; @@ -1065,132 +788,42 @@ } // ----------------------------------------------------------------------------- -// CCalenDeleteUi::DeleteEntryL +// CalenDeleteUi::DeleteEntryL // Delete entry using entry local uid // ----------------------------------------------------------------------------- // -void CCalenDeleteUi::DeleteEntryL(TCalLocalUid& aEntryLocalUid, TInt aColId) +void CalenDeleteUi::DeleteEntryL(ulong& aEntryLocalUid) { TRACE_ENTRY_POINT; - // fetch the entry - CCalEntry* entry = iGlobalData->EntryViewL(aColId)->FetchL(aEntryLocalUid); - if( entry ) - { - CleanupStack::PushL( entry ); - iGlobalData->EntryViewL(aColId)->DeleteL( *entry ); - CleanupStack::Pop( entry ); - delete entry; - entry = NULL; - } + iController.Services().agendaInterface()->deleteEntry(aEntryLocalUid); TRACE_EXIT_POINT; } // ----------------------------------------------------------------------------- -// CCalenDeleteUi::DisplayWaitDialogL +// CalenDeleteUi::DisplayWaitDialogL // Display wait dialog // ----------------------------------------------------------------------------- // -void CCalenDeleteUi::DisplayWaitDialogL() +void CalenDeleteUi::DisplayWaitDialogL() { - TRACE_ENTRY_POINT; - - delete iWaitDialog; - iWaitDialog = NULL; - iWaitDialog = new( ELeave )CAknWaitDialog( REINTERPRET_CAST( CEikDialog**, &iWaitDialog ), ETrue ); - iWaitDialog->ExecuteLD( R_TODO_VIEW_DELETE_WAIT_NOTE ); - iWaitDialog->SetCallback(this); - + TRACE_ENTRY_POINT; TRACE_EXIT_POINT; } // ----------------------------------------------------------------------------- -// CCalenDeleteUi::MarkedEntriesDeletedL +// CalenDeleteUi::MarkedEntriesDeletedL // Dismiss wait dialog and show information note // ----------------------------------------------------------------------------- // -void CCalenDeleteUi::MarkedEntriesDeletedL() +void CalenDeleteUi::MarkedEntriesDeletedL() { - TRACE_ENTRY_POINT; - - // dismiss the waitdialog - if(iWaitDialog) - { - iWaitDialog->ProcessFinishedL(); - } - - // Show confirmation note - //HBufC* buf = StringLoader::LoadLC( R_QTN_CALE_CONF_ALL_NOTES_DELETED, iEikEnv ); - //CAknConfirmationNote* dialog = new( ELeave ) CAknConfirmationNote(); - //dialog->ExecuteLD(*buf); - //CleanupStack::PopAndDestroy( buf ); - + TRACE_ENTRY_POINT; // notify marked entries deleted iController.BroadcastNotification( ECalenNotifyMarkedEntryDeleted ); TRACE_EXIT_POINT; } -// ----------------------------------------------------------------------------- -// CCalenDeleteUi::HandleDeleteAllEntriesL -// Handles launching of the delete all entries list query -// ----------------------------------------------------------------------------- -// -void CCalenDeleteUi::HandleDeleteAllEntriesL() - { - TRACE_ENTRY_POINT; - RPointerArray calendarInfoList; - CleanupClosePushL(calendarInfoList); - iController.Services().GetAllCalendarInfoL(calendarInfoList); - TInt visibleCalendarsCount(0); - for(TInt index=0;indexEnabled()) - { - visibleCalendarsCount++; - } - if(visibleCalendarsCount>1) - { - break; - } - } - CleanupStack::PopAndDestroy(); - - TInt headingTextResourceId(0); - if(visibleCalendarsCount==1) - { - headingTextResourceId = R_CALE_SINGLE_CALENDAR_DELETE_ENTRIES; - } - else - { - headingTextResourceId = R_CALE_MULTI_CALENDAR_DELETE_ENTRIES; - } - - TInt selectedIndex(0); - CAknListQueryDialog* deleteEntriesListDialog = new(ELeave) CAknListQueryDialog(&selectedIndex); - deleteEntriesListDialog->PrepareLC(R_DELETE_ENTRIES_LIST_QUERY); - HBufC* buf = StringLoader::LoadLC( headingTextResourceId, iEikEnv ); - deleteEntriesListDialog->QueryHeading()->SetTextL(buf->Des()); - CleanupStack::PopAndDestroy( buf ); - - if(deleteEntriesListDialog->RunLD()) - { - if(selectedIndex) - { - DeleteAllEntriesL(); - } - else - { - DeleteEntriesBeforeDateL(); - } - } - else - { - iController.BroadcastNotification(ECalenNotifyDeleteFailed); - } - - TRACE_EXIT_POINT - } - // End of File