diff -r 12af337248b1 -r bd7edf625bdd calendarui/controller/src/calendeleteui.cpp --- a/calendarui/controller/src/calendeleteui.cpp Tue Aug 31 15:13:43 2010 +0300 +++ b/calendarui/controller/src/calendeleteui.cpp Wed Sep 01 12:32:31 2010 +0100 @@ -1,5 +1,5 @@ /* -* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* Copyright (c) 2007 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,233 +15,332 @@ * */ -// System includes -#include -#include -#include -#include -#include -#include -#include -#include + +// INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include -#include +#include +#include +#include +#include +#include +#include +#include // Calendar commands +#include +#include // TCalenInstanceId +#include +#include +#include +#include +#include -// User includes -#include "calendarui_debug.h" +#include "calendarui_debug.h" // Debug #include "calendeleteui.h" -#include "calencontext.h" #include "calencontroller.h" #include "CleanupResetAndDestroy.h" -#include "caleninstanceid.h" -#include "calenactionuiutils.h" -#include "calendateutils.h" -#include "calenagendautils.h" -#include "OstTraceDefinitions.h" -#ifdef OST_TRACE_COMPILER_IN_USE -#include "calendeleteuiTraces.h" -#endif - +#include "CalenInterimUtils2.h" +#include "CalendarPrivateCRKeys.h" // For CalendarInternalCRKeys.h +#include "calenmultipledbmanager.h" // Local constants const TInt KEntriesToDelete = 1; // ---------------------------------------------------------------------------- -// CalenDeleteUi::NewL +// CCalenDeleteUi::NewL // Two phased constructor // (other items were commented in a header). // ---------------------------------------------------------------------------- // -CalenDeleteUi* CalenDeleteUi::NewL( CCalenController& aController ) +CCalenDeleteUi* CCalenDeleteUi::NewL( CCalenController& aController ) { - OstTraceFunctionEntry0( CALENDELETEUI_NEWL_ENTRY ); - - CalenDeleteUi* self = new( ELeave ) CalenDeleteUi( aController, NULL ); + TRACE_ENTRY_POINT; + + CCalenDeleteUi* self = new( ELeave ) CCalenDeleteUi( aController ); CleanupStack::PushL( self ); self->ConstructL(); CleanupStack::Pop( self ); - OstTraceFunctionExit0( CALENDELETEUI_NEWL_EXIT ); + TRACE_EXIT_POINT; return self; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::CalenDeleteUi +// CCalenDeleteUi::CCalenDeleteUi // ?implementation_description // (other items were commented in a header). // ---------------------------------------------------------------------------- // -CalenDeleteUi::CalenDeleteUi( CCalenController& aController, QObject *parent ) - :QObject(parent), iController( aController ) +CCalenDeleteUi::CCalenDeleteUi( CCalenController& aController ) + : iEikEnv( CEikonEnv::Static() ), iController( aController ) { - OstTraceFunctionEntry0( CALENDELETEUI_CALENDELETEUI_ENTRY ); - - iIsDeleting = false; - - OstTraceFunctionExit0( CALENDELETEUI_CALENDELETEUI_EXIT ); + TRACE_ENTRY_POINT; + TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::~CalenDeleteUi +// CCalenDeleteUi::~CCalenDeleteUi // Destructor // (other items were commented in a header). // ---------------------------------------------------------------------------- // -CalenDeleteUi::~CalenDeleteUi() +CCalenDeleteUi::~CCalenDeleteUi() { - OstTraceFunctionEntry0( DUP1_CALENDELETEUI_CALENDELETEUI_ENTRY ); + TRACE_ENTRY_POINT; + + if( iWaitDialog ) + { + delete iWaitDialog; + iWaitDialog = NULL; + } + + if( iGlobalData ) + { + iGlobalData->Release(); + } + + if( iDelAllRange ) + delete iDelAllRange; + + iDeleteColIds.Reset(); - OstTraceFunctionExit0( DUP1_CALENDELETEUI_CALENDELETEUI_EXIT ); + TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::ConstructL +// CCalenDeleteUi::ConstructL // Second phase of construction // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CalenDeleteUi::ConstructL() +void CCalenDeleteUi::ConstructL() { - OstTraceFunctionEntry0( CALENDELETEUI_CONSTRUCTL_ENTRY ); + 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; - - OstTraceFunctionExit0( CALENDELETEUI_CONSTRUCTL_EXIT ); + iDelAllRange = NULL; + TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::HandleNotification +// 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 // Handles notifications. // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CalenDeleteUi::HandleNotification(const TCalenNotification aNotification ) +void CCalenDeleteUi::HandleNotification(const TCalenNotification aNotification ) { - OstTraceFunctionEntry0( CALENDELETEUI_HANDLENOTIFICATION_ENTRY ); + TRACE_ENTRY_POINT; + if ( aNotification == ECalenNotifyEntryInstanceViewCreated ) + { + PIM_TRAPD_HANDLE( HandleECalenNotifyViewCreatedL() ); + } if( aNotification == ECalenNotifyCancelDelete) { if(iMutlipleContextIdsCount) { // get the context - MCalenContext& context = iController.context(); + MCalenContext& context = iGlobalData->Context(); // reset the multiple contexts - context.resetMultipleContextIds(); - + context.ResetMultipleContextIds(); + + // dismiss the waitdialog + if(iWaitDialog) + { + TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); + } } } - - OstTraceFunctionExit0( CALENDELETEUI_HANDLENOTIFICATION_EXIT ); + TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::HandleCommandL +// CCalenDeleteUi::HandleCommandL // Handles action ui commands // (other items were commented in a header). // ---------------------------------------------------------------------------- // -TBool CalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand ) +TBool CCalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand ) { - OstTraceFunctionEntry0( CALENDELETEUI_HANDLECOMMANDL_ENTRY ); - + TRACE_ENTRY_POINT; TBool continueCommand(EFalse); - switch( aCommand.Command() ) + RArray colArray; + iController.GetActiveCollectionidsL(colArray); + + if( colArray.Count() && !( iGlobalData->InstanceViewL(colArray) ) ) { - case ECalenDeleteCurrentEntry: - mDeleteCommand = ECalenDeleteCurrentEntry; - DeleteCurrentEntryL(); // Entry & instance - break; + iStoredCommand = aCommand; + } + else + { + switch( aCommand.Command() ) + { + case ECalenDeleteCurrentEntry: + DeleteCurrentEntryL(); // Entry & instance + break; - case ECalenDeleteSeries: - mDeleteCommand = ECalenDeleteSeries; - DeleteThisOrAllL( AgendaUtil::ThisAndAll ); - break; - - case ECalenDeleteCurrentOccurrence: - mDeleteCommand = ECalenDeleteCurrentOccurrence; - DeleteThisOrAllL( AgendaUtil::ThisOnly ); - break; - - case ECalenDeleteEntryWithoutQuery: - //TODO: - // This case is not handled currently as no such commands - // has been issued. So this has to be handled once we start - // issuing the command. - /*continueCommand = DeleteEntryWithoutQueryL();*/ - break; + case ECalenDeleteSeries: + DeleteThisOrAllL( CalCommon::EThisAndAll ); + break; + + case ECalenDeleteCurrentOccurrence: + DeleteThisOrAllL( CalCommon::EThisOnly ); + break; + + case ECalenDeleteEntryWithoutQuery: + continueCommand = DeleteEntryWithoutQueryL(); + break; - case ECalenDeleteAllEntries: - mDeleteCommand = ECalenDeleteAllEntries; - DeleteAllEntriesL(); // EntryView & instance - break; + case ECalenDeleteAllEntries: + HandleDeleteAllEntriesL(); + 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; + } } - - OstTraceFunctionExit0( CALENDELETEUI_HANDLECOMMANDL_EXIT ); + 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; + } // ---------------------------------------------------------------------------- -// CalenDeleteUi::DeleteThisOrAllL +// CCalenDeleteUi::DeleteThisOrAllL // Deletes series repeating entry // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CalenDeleteUi::DeleteThisOrAllL( AgendaUtil::RecurrenceRange aRepeatType ) -{ - OstTraceFunctionEntry0( CALENDELETEUI_DELETETHISORALLL_ENTRY ); - - if( iController.context().instanceId().mEntryLocalUid ) - { - AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL( - iController.context().instanceId(), - iController.Services().agendaInterface() ); - if( !instance.isNull() ) - { - DeleteSingleInstanceL( instance, aRepeatType ); - } - } - - OstTraceFunctionExit0( CALENDELETEUI_DELETETHISORALLL_EXIT ); -} +void CCalenDeleteUi::DeleteThisOrAllL( CalCommon::TRecurrenceRange aRepeatType ) + { + TRACE_ENTRY_POINT; + + TBool isDeleted( EFalse ); + + RArray colIdArray; + colIdArray.AppendL(iGlobalData->Context().InstanceId().iColId); + + if( iGlobalData->Context().InstanceId().iEntryLocalUid ) + { + CCalInstance* instance = + CalenActionUiUtils::FindPossibleInstanceL( + iGlobalData->Context().InstanceId(), + *iGlobalData->InstanceViewL(colIdArray) ); + if( instance ) + { + CleanupStack::PushL( instance ); + isDeleted = DeleteSingleInstanceL( instance, aRepeatType ); + + if( isDeleted ) + { + CleanupStack::Pop( instance ); + } + else + { + CleanupStack::PopAndDestroy( instance ); + } + } + } + colIdArray.Reset(); + + iController.BroadcastNotification( isDeleted? ECalenNotifyEntryDeleted : + ECalenNotifyDeleteFailed ); + + TRACE_EXIT_POINT; + } // ---------------------------------------------------------------------------- -// CalenDeleteUi::DeleteEntryWithoutQueryL() +// CCalenDeleteUi::DeleteEntryWithoutQueryL() // Deletes the current entry // (other items were commented in a header). // ---------------------------------------------------------------------------- // -TBool CalenDeleteUi::DeleteEntryWithoutQueryL() +TBool CCalenDeleteUi::DeleteEntryWithoutQueryL() { - OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRYWITHOUTQUERYL_ENTRY ); - - bool continueCommand(EFalse); + TRACE_ENTRY_POINT; + TBool continueCommand(EFalse); // get the context - MCalenContext& context = iController.context(); + MCalenContext& context = iGlobalData->Context(); // get the multliple context ids count - iMutlipleContextIdsCount = context.mutlipleContextIdsCount(); + iMutlipleContextIdsCount = context.MutlipleContextIdsCount(); ASSERT( iMutlipleContextIdsCount ); if(!iMoreEntriesToDelete) { - //iDisplayQuery = ShowMultipleEntriesDeleteQueryL(iMutlipleContextIdsCount); + iDisplayQuery = ShowMultipleEntriesDeleteQueryL(iMutlipleContextIdsCount); } if(iDisplayQuery) @@ -251,7 +350,7 @@ DisplayWaitDialogL(); } // get the multiple context instance ids - QList& multipleContextIds = context.getMutlipleContextIds(); + RArray& multipleContextIds = context.GetMutlipleContextIds(); if(iMutlipleContextIdsCount <= iEntriesToDelete ) { @@ -269,13 +368,13 @@ while(indexToolbar(); + + // dim clear and clear all toolbar buttons + toolbar.SetItemDimmed(ECalenNewMeeting, EFalse, ETrue); + } } else { - context.resetMultipleContextIds(); + context.ResetMultipleContextIds(); // notify delete failed iController.BroadcastNotification(ECalenNotifyDeleteFailed); } - OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRYWITHOUTQUERYL_EXIT ); + TRACE_EXIT_POINT; return continueCommand; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::DeleteCurrentEntryL +// CCalenDeleteUi::DeleteCurrentEntryL // Deletes the current entry // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CalenDeleteUi::DeleteCurrentEntryL() -{ - OstTraceFunctionEntry0( CALENDELETEUI_DELETECURRENTENTRYL_ENTRY ); +void CCalenDeleteUi::DeleteCurrentEntryL() + { + TRACE_ENTRY_POINT; + + TBool deleted( EFalse ); + TCalenNotification notification = ECalenNotifyDeleteFailed; - // Make sure we're focused on an 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()) { - showDeleteQuery(EDeleteToDo); - } else { - // Show the repeat entry delete query for repeating entries except Anniversary - // Even though the anniversary is repeating - // all the instances will be deleted - if ((entry.isRepeating() || !entry.recurrenceId().isNull()) - && (AgendaEntry::TypeAnniversary != entry.type())) { - // Show a confirmation note whether the user - // wants to delete the single instance or all of them - showRepeatingEntryDeleteQuery(); - } else if (CalenAgendaUtils::isAlldayEvent(entry)) { - showDeleteQuery(EDeleteEvent); - } else { - // If the entry is not a repeating entry, - // delete it directly - // Save the entry for later reference in the slot - showDeleteQuery(EDeleteEntry); - } + // Make sure we're focused on an entry. + if( iGlobalData->Context().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 ); + 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 ); + 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; } - } - OstTraceFunctionExit0( CALENDELETEUI_DELETECURRENTENTRYL_EXIT ); -} + } + + iController.BroadcastNotification( notification ); + + TRACE_EXIT_POINT; + } // ---------------------------------------------------------------------------- -// CalenDeleteUi::DeleteAllEntriesL +// CCalenDeleteUi::DeleteAllEntriesL // Deletes all entries // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CalenDeleteUi::DeleteAllEntriesL() +void CCalenDeleteUi::DeleteAllEntriesL() { - OstTraceFunctionEntry0( CALENDELETEUI_DELETEALLENTRIESL_ENTRY ); - - if(iIsDeleting) { - OstTraceFunctionExit0( CALENDELETEUI_DELETEALLENTRIESL_EXIT ); - return; - } + TRACE_ENTRY_POINT; + + ASSERT( !iIsDeleting ); + + const TInt buttonId = CalenActionUiUtils::ShowDeleteConfirmationQueryL( + CalenActionUiUtils::EDeleteAll ); - showDeleteQuery(EDeleteAll ); - OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETEALLENTRIESL_EXIT ); - } + if( buttonId ) + { + HandleDeleteMultipleEventsL( TCalTime::MinTime(), TCalTime::MaxTime(), + R_QTN_CALE_CONF_ALL_NOTES_DELETED ); + } + else + { + // notify delete failed + iController.BroadcastNotification(ECalenNotifyDeleteFailed); + } + + TRACE_EXIT_POINT; + } // ---------------------------------------------------------------------------- -// CalenDeleteUi::DeleteEntriesBeforeDateL +// CCalenDeleteUi::DeleteEntriesBeforeDateL // Deletes all entries before a set date. // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CalenDeleteUi::DeleteEntriesBeforeDateL() +void CCalenDeleteUi::DeleteEntriesBeforeDateL() { - OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRIESBEFOREDATEL_ENTRY ); + TRACE_ENTRY_POINT; + + ASSERT( !iIsDeleting ); + TTime date; + date.HomeTime(); + TTime today = date; + + TBool execute( EFalse ); + TBool exit( ETrue ); + do{ + exit = ETrue; + execute = EFalse; + + TInt buttonId = CalenActionUiUtils::DateQueryL(date, R_CALEN_DEL_BEFORE_DATE_PROMPT); + + if( buttonId == EAknSoftkeyOk || buttonId == EEikBidOk ) + { + 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 ); + + // 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( TCalTime::MinTime(), + date, + R_QTN_CALE_CONF_PAST_NOTE_DELETED ); + } + else + { + iController.BroadcastNotification( ECalenNotifyDeleteFailed ); + } - if(iIsDeleting) { - OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRIESBEFOREDATEL_EXIT ); - return; - } - // launch the datepicker - dateQuery(); - OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETEENTRIESBEFOREDATEL_EXIT ); + TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::dateQuery -// Launches the popup for the date selection -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -void CalenDeleteUi::dateQuery() - { - OstTraceFunctionEntry0( CALENDELETEUI_DATEQUERY_ENTRY ); - - // Create a popup with datepicker to select the date. - HbDialog *popUp = new HbDialog(); - popUp->setDismissPolicy(HbDialog::NoDismiss); - popUp->setTimeout(HbDialog::NoTimeout ); - popUp->setAttribute( Qt::WA_DeleteOnClose, true ); - popUp->setHeadingWidget(new HbLabel(hbTrId("txt_calendar_title_set_date"))); - - QDateTime currentDateTime(CalenDateUtils::today()); - QDate currentDate(currentDateTime.date()); - if(mDatePicker) { - mDatePicker = NULL; - } - mDatePicker = new HbDateTimePicker(popUp); - mDatePicker->setMinimumDate(CalenDateUtils::minTime().date()); - mDatePicker->setMaximumDate(currentDate); - mDatePicker->setDate(currentDate); - - popUp->setContentWidget(mDatePicker); - mDeleteAction = new HbAction( - hbTrId("txt_common_button_delete"), popUp); - popUp->addAction(mDeleteAction); - mCancelAction = new HbAction(hbTrId("txt_common_button_cancel"),popUp); - popUp->addAction(mCancelAction); - // Show the popup - popUp->open(this, SLOT(handleDateQuery(HbAction*))); - - OstTraceFunctionExit0( CALENDELETEUI_DATEQUERY_EXIT ); - } - -// ---------------------------------------------------------------------------- -// CalenDeleteUi::handleDateQuery -// Handles the selection for the date query -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -void CalenDeleteUi::handleDateQuery(HbAction* action) -{ - OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDATEQUERY_ENTRY ); - - if(action == mDeleteAction) { - // User selected the date before which all the entries has to be deleted - QDate selectedDate(mDatePicker->date()); - // Check if the date is within the range. - if(selectedDate.isValid()) { - QTime time(0,0,0,0); - QDateTime dateTime; - dateTime.setDate(selectedDate); - dateTime.setTime(time); - // Do delete only if inputted day is after beginning of range - if(dateTime > AgendaUtil::minTime()) { - // Two pass delete: - // 1. pass - // To prevent destroying entries starting and ending midnight - // subtract one second and do delete on that range. - dateTime = dateTime.addSecs(-1); - dateTime = ( dateTime > AgendaUtil::minTime()? - dateTime : AgendaUtil::minTime()); - - HandleDeleteMultipleEventsL( AgendaUtil::minTime(), - dateTime, 1); - }else { - iController.BroadcastNotification(ECalenNotifyDeleteFailed); - } - } - }else { - // User pressed cancel - handleDeleteCancel(); - } - // Reset the member variables - mDeleteAction = NULL; - mCancelAction = NULL; - - OstTraceFunctionExit0( CALENDELETEUI_HANDLEDATEQUERY_EXIT ); -} -// ---------------------------------------------------------------------------- -// CalenDeleteUi::showRepeatingEntryDeleteQuery -// Launches the popup for deleting the repeating entry -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -void CalenDeleteUi::showRepeatingEntryDeleteQuery() -{ - OstTraceFunctionEntry0( CALENDELETEUI_SHOWREPEATINGENTRYDELETEQUERY_ENTRY ); - - HbDialog *popUp = new HbDialog(); - popUp->setDismissPolicy(HbDialog::NoDismiss); - popUp->setTimeout(HbDialog::NoTimeout); - popUp->setAttribute( Qt::WA_DeleteOnClose, true ); - - 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"))); - - // Add cancel action - HbAction *cancelAction = new HbAction( - hbTrId("txt_common_button_cancel_singledialog")); - popUp->addAction(cancelAction); - connect(editButtonList, SIGNAL(itemSelected(int)), this, - SLOT(handleRepeatedEntryDelete(int))); - connect(editButtonList, SIGNAL(itemSelected(int)), popUp, SLOT(close())); - connect(cancelAction, SIGNAL(triggered()), this, - SLOT(handleDeleteCancel())); - - // Show the popup - popUp->open(); - - OstTraceFunctionExit0( CALENDELETEUI_SHOWREPEATINGENTRYDELETEQUERY_EXIT ); -} - -// ---------------------------------------------------------------------------- -// CalenDeleteUi::handleDeleteCancel -// Handles the cancel action -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -void CalenDeleteUi::handleDeleteCancel() -{ - OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDELETECANCEL_ENTRY ); - - iController.BroadcastNotification(ECalenNotifyDeleteFailed); - - OstTraceFunctionExit0( CALENDELETEUI_HANDLEDELETECANCEL_EXIT ); -} - -void CalenDeleteUi::handleRepeatedEntryDelete(int index) -{ - OstTraceFunctionEntry0( CALENDELETEUI_HANDLEREPEATEDENTRYDELETE_ENTRY ); - - // 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; - } - }else { - iController.BroadcastNotification(ECalenNotifyDeleteFailed); - } - OstTraceFunctionExit0( CALENDELETEUI_HANDLEREPEATEDENTRYDELETE_EXIT ); -} - -// ---------------------------------------------------------------------------- -// CalenDeleteUi::showDeleteQuery -// Launches the popup for deleting the instance/instances -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -void CalenDeleteUi::showDeleteQuery(const TDeleteConfirmationType type, - const int count) - { - OstTraceFunctionEntry0( CALENDELETEUI_SHOWDELETEQUERY_ENTRY ); - - HbMessageBox *popup = new HbMessageBox(HbMessageBox::MessageTypeQuestion); - popup->setDismissPolicy(HbDialog::NoDismiss); - popup->setTimeout(HbDialog::NoTimeout); - popup->setAttribute( Qt::WA_DeleteOnClose, true ); - - QString text = 0; - - switch(type) - { - case EDeleteEntry: - { - text.append(hbTrId("txt_calendar_info_delete_meeting")); - break; - } - case EDeleteToDo: - { - text.append(hbTrId("txt_calendar_info_delete_todo_note")); - break; - } - case EDeleteToDos: - {//"Delete %N to-do notes?" - // TODO: Add the text id - text.append("Delete %N to-do's?").arg(count); - break; - } - case EDeleteAll: - { - text.append(hbTrId("txt_calendar_info_delete_all_calendar_entries")); - break; - } - case EDeleteEvent: - { - text.append(hbTrId("txt_calendar_info_delete_allday_event")); - break; - } - default: - break; - } - - popup->setText(text); - - QList list = popup->actions(); - for(int i=0; i < list.count(); i++) - { - popup->removeAction(list[i]); - } - mDeleteAction = new HbAction( - hbTrId("txt_common_button_delete"), popup); - popup->addAction(mDeleteAction); - mCancelAction = new HbAction(hbTrId("txt_common_button_cancel"), popup); - popup->addAction(mCancelAction); - popup->open(this, SLOT(handleDeletion(HbAction*))); - - OstTraceFunctionExit0( CALENDELETEUI_SHOWDELETEQUERY_EXIT ); - } - -// ---------------------------------------------------------------------------- -// CalenDeleteUi::handleDeletion -// Deletes the entries based on the user selection -// (other items were commented in a header). -// ---------------------------------------------------------------------------- -// -void CalenDeleteUi::handleDeletion(HbAction* action) -{ - OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDELETION_ENTRY ); - - TCalenNotification notification = ECalenNotifyDeleteFailed; - - if(action == mDeleteAction) { - - switch (mDeleteCommand) { - - case ECalenDeleteCurrentEntry: - { - // Get the entry id - ulong id = iController.context().instanceId().mEntryLocalUid; - connect(iController.Services().agendaInterface(), - SIGNAL(entryDeleted(ulong)), - this, SLOT(entryDeleted(ulong))); - // Delete the entry if the delete button is been pressed - iController.Services().agendaInterface()->deleteEntry(id); - } - break; - - case ECalenDeleteSeries: - case ECalenDeleteCurrentOccurrence: - { - AgendaEntry instance = - CalenActionUiUtils::findPossibleInstanceL( - iController.context().instanceId(), - iController.Services().agendaInterface() ); - if(!instance.isNull()) { - QDateTime recId = instance.recurrenceId().toUTC(); - const bool child = recId.isNull(); - connect(iController.Services().agendaInterface(), - SIGNAL(entryDeleted(ulong)), - this, SLOT(entryDeleted(ulong))); - if( !child || mRecurrenceRange == AgendaUtil::ThisOnly - || mRecurrenceRange == AgendaUtil::ThisAndAll) { - iController.Services().agendaInterface()->deleteRepeatedEntry( - instance, mRecurrenceRange ); - } - }else { - iController.BroadcastNotification(ECalenNotifyDeleteFailed); - } - } - break; - - case ECalenDeleteAllEntries: - { - HandleDeleteMultipleEventsL( AgendaUtil::minTime(), - AgendaUtil::maxTime(),1 ); - } - break; - - default: - break; - - } - } else { - // If the user presses cancel button the notification will be - // ECalenNotifyDeleteFailed as default. - // Notify the status - iController.BroadcastNotification(notification); - } - - // Reset the member variables - mDeleteAction = NULL; - mCancelAction = NULL; - - OstTraceFunctionExit0( CALENDELETEUI_HANDLEDELETION_EXIT ); -} - -void CalenDeleteUi::entryDeleted(ulong id) -{ - OstTraceFunctionEntry0( CALENDELETEUI_ENTRYDELETED_ENTRY ); - - if (iController.context().instanceId().mEntryLocalUid == id) { - iController.BroadcastNotification(ECalenNotifyEntryDeleted); - } - disconnect(iController.Services().agendaInterface(), SIGNAL(entryDeleted(ulong)), - this, SLOT(entryDeleted(ulong))); - - OstTraceFunctionExit0( CALENDELETEUI_ENTRYDELETED_EXIT ); -} - -// ---------------------------------------------------------------------------- -// CalenDeleteUi::HandleDeleteMultipleEventsL +// CCalenDeleteUi::HandleDeleteMultipleEventsL // Handles multiple delete events // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CalenDeleteUi::HandleDeleteMultipleEventsL( const QDateTime& aFirstDay, - const QDateTime& aLastDay, - int aConfNoteId ) +void CCalenDeleteUi::HandleDeleteMultipleEventsL( const TTime& aFirstDay, + const TTime& aLastDay, + TInt /*aConfNoteId */) { - OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDELETEMULTIPLEEVENTSL_ENTRY ); - - if(iIsDeleting) { - OstTraceFunctionExit0( CALENDELETEUI_HANDLEDELETEMULTIPLEEVENTSL_EXIT ); - return; - } - iConfirmationNoteId = 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 ); - OstTraceFunctionExit0( DUP1_CALENDELETEUI_HANDLEDELETEMULTIPLEEVENTSL_EXIT ); + TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::DeleteDayRangeL +// CCalenDeleteUi::DeleteDayRangeL // Deletes all entries in a given range. // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CalenDeleteUi::DeleteDayRangeL( const QDateTime& aStart, - const QDateTime& aEnd ) +void CCalenDeleteUi::DeleteDayRangeL( const TTime& aStart, + const TTime& aEnd ) { - OstTraceFunctionEntry0( CALENDELETEUI_DELETEDAYRANGEL_ENTRY ); - + TRACE_ENTRY_POINT; + iStartTime = aStart; iEndTime = aEnd; - - iIsDeleting = ETrue; + + TCalTime start, end; + start.SetTimeLocalL( iStartTime ); + end.SetTimeLocalL( iEndTime ); + + if( iDelAllRange ) + { + delete iDelAllRange; + iDelAllRange = NULL; + } - //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))); - AgendaUtil::FilterFlags filter = - AgendaUtil::FilterFlags(AgendaUtil::IncludeAnniversaries - | AgendaUtil::IncludeAppointments - | AgendaUtil::IncludeEvents - | AgendaUtil::IncludeReminders - | AgendaUtil::IncludeIncompletedTodos - | AgendaUtil::IncludeCompletedTodos - | AgendaUtil::IncludeAnniversaries); - // 1: First pass, delete all entries. - iController.agendaInterface()->deleteEntries(iStartTime, iEndTime, filter); + iDelAllRange = new(ELeave) CalCommon::TCalTimeRange( start, end ); + iDeleteColIds.Reset(); + + iIsDeleting = ETrue; - OstTraceFunctionExit0( CALENDELETEUI_DELETEDAYRANGEL_EXIT ); + 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; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::DoCompletedL +// CCalenDeleteUi::Completed +// Completed callback +// (other items were commented in a header). +// ---------------------------------------------------------------------------- +// +void CCalenDeleteUi::Completed( TInt aFirstPassError ) + { + TRACE_ENTRY_POINT; + + PIM_TRAPD_HANDLE( DoCompletedL( aFirstPassError ) ); + + TRACE_EXIT_POINT; + } + +// ---------------------------------------------------------------------------- +// CCalenDeleteUi::DoCompletedL // Handles delete callback // (other items were commented in a header). // ---------------------------------------------------------------------------- // -void CalenDeleteUi::doCompleted( int aFirstPassError ) +void CCalenDeleteUi::DoCompletedL( TInt aFirstPassError ) { - OstTraceFunctionEntry0( CALENDELETEUI_DOCOMPLETED_ENTRY ); - - if( aFirstPassError == KErrNone ) + TRACE_ENTRY_POINT; + iToShowDeleteNote++; + if(iNumberOfCalendars == iToShowDeleteNote) { - // 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 ) ); + 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()); + } + + 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 + { + //delete entries in next calendar... + iGlobalData->EntryViewL(iDeleteColIds[iToShowDeleteNote])->DeleteL( *iDelAllRange, CalCommon::EIncludeAll, *this ); } - // 3. End deleting, close wait dialog, and show confirmation or error note - iIsDeleting = EFalse; - - iController.BroadcastNotification( ECalenNotifyMultipleEntriesDeleted ); - - OstTraceFunctionExit0( CALENDELETEUI_DOCOMPLETED_EXIT ); + TRACE_EXIT_POINT; } // ---------------------------------------------------------------------------- -// CalenDeleteUi::DeleteEntriesEndingAtMidnightL +// 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 CalenDeleteUi::deleteEntriesEndingAtMidnight( QDateTime aMidnight ) +void CCalenDeleteUi::DeleteEntriesEndingAtMidnightL( TTime aMidnight ) { - OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRIESENDINGATMIDNIGHT_ENTRY ); + TRACE_ENTRY_POINT; - 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); + TCalTime start, end; + start.SetTimeLocalL( aMidnight - TTimeIntervalMinutes(1) ); + end.SetTimeLocalL( aMidnight ); + CalCommon::TCalTimeRange midnightRange( start, end ); + + RArray colIdArray; + iController.GetActiveCollectionidsL(colIdArray); - end = aMidnight; + // 1: Find instances falling on midnight moment + RPointerArray< CCalInstance > instances; + CleanupResetAndDestroyPushL( instances ); + iGlobalData->InstanceViewL(colIdArray)->FindInstanceL( instances, + CalCommon::EIncludeAll, + midnightRange ); - QList instances = iController.Services().agendaInterface()->fetchEntriesInRange( start, end ); + colIdArray.Reset(); // 2. loop through them and delete those entries that end at midnight - for( int i=0; i < instances.count(); ++i ) + for( TInt i=0; i < instances.Count(); ++i ) { - AgendaEntry entry = instances[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::endsAtStartOfDay( entry, aMidnight ) ) + 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( entry.endTime() == aMidnight ) + if( item->Entry().EndTimeL().TimeLocalL() == aMidnight ) { - iController.Services().agendaInterface()->deleteRepeatedEntry(entry, AgendaUtil::ThisAndAll); + 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 ); - OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRIESENDINGATMIDNIGHT_EXIT ); + TRACE_EXIT_POINT; } // ----------------------------------------------------------------------------- -// CalenDeleteUi::DeleteSingleInstanceL +// CCalenDeleteUi::DeleteSingleInstanceL // Delete the given instance. Ask the user whether to delete the series or the instance. // (other items were commented in a header). // ----------------------------------------------------------------------------- // -void CalenDeleteUi::DeleteSingleInstanceL( AgendaEntry& aInstance ) +TBool CCalenDeleteUi::DeleteSingleInstanceL( CCalInstance* aInstance ) { - OstTraceFunctionEntry0( CALENDELETEUI_DELETESINGLEINSTANCEL_ENTRY ); - - DoDeleteSingleInstanceL( aInstance, EFalse, AgendaUtil::ThisAndAll ); - - OstTraceFunctionExit0( CALENDELETEUI_DELETESINGLEINSTANCEL_EXIT ); + TRACE_ENTRY_POINT; + TRACE_EXIT_POINT; + return DoDeleteSingleInstanceL( aInstance, EFalse, CalCommon::EThisAndAll ); } // ----------------------------------------------------------------------------- -// CalenDeleteUi::DeleteSingleInstanceL +// CCalenDeleteUi::DeleteSingleInstanceL // Delete the given instance. Delete the entry range given by aRepeatType. // (other items were commented in a header). // ----------------------------------------------------------------------------- // -void CalenDeleteUi::DeleteSingleInstanceL( AgendaEntry& aInstance, - AgendaUtil::RecurrenceRange aRepeatType ) +TBool CCalenDeleteUi::DeleteSingleInstanceL( CCalInstance* aInstance, + CalCommon::TRecurrenceRange aRepeatType ) { - OstTraceFunctionEntry0( DUP1_CALENDELETEUI_DELETESINGLEINSTANCEL_ENTRY ); - - DoDeleteSingleInstanceL( aInstance, ETrue, aRepeatType ); - - OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETESINGLEINSTANCEL_EXIT ); + TRACE_ENTRY_POINT; + TRACE_EXIT_POINT; + return DoDeleteSingleInstanceL( aInstance, ETrue, aRepeatType ); } // ----------------------------------------------------------------------------- -// CalenDeleteUi::DoDeleteSingleInstanceL +// CCalenDeleteUi::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 @@ -880,54 +841,241 @@ // (other items were commented in a header). // ----------------------------------------------------------------------------- // -void CalenDeleteUi::DoDeleteSingleInstanceL( - AgendaEntry& aInstance, - bool aHasRepeatType, - AgendaUtil::RecurrenceRange aRepeatType ) -{ - OstTraceFunctionEntry0( CALENDELETEUI_DODELETESINGLEINSTANCEL_ENTRY ); +TBool CCalenDeleteUi::DoDeleteSingleInstanceL( CCalInstance* aInstance, + TBool aHasRepeatType, + CalCommon::TRecurrenceRange aRepeatType ) + { + TRACE_ENTRY_POINT; + + CCalEntry& entry = aInstance->Entry(); + const CCalEntry::TType entryType = entry.EntryTypeL(); + RArray colIdArray; + colIdArray.AppendL(aInstance->InstanceIdL().iCollectionId); - bool repeating = aInstance.isRepeating(); + + TCalRRule rrule; + + TBool repeating = entry.GetRRuleL( rrule ); - if( !repeating ) { - // Even though there is no RRule, the entry might - // have a list of rdates. - QList rDates = aInstance.rDates(); - repeating = ( rDates.count() > 0 ); - } - QDateTime recId = aInstance.recurrenceId().toUTC(); - const bool child = recId.isNull(); + 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 + } + + const TBool child = entry.RecurrenceIdL().TimeUtcL() != Time::NullTTime(); + + if( !aHasRepeatType ) + { + aRepeatType = CalCommon::EThisAndAll; + } + + TBool doDelete( ETrue ); - if( !aHasRepeatType ) { - aRepeatType = AgendaUtil::ThisAndAll; - } - // For later reference in handleDeletion() - mRecurrenceRange = aRepeatType; + if( !aHasRepeatType && ( child || repeating ) && ( entryType != CCalEntry::EAnniv ) ) + { + doDelete = CalenActionUiUtils::ShowRepeatTypeQueryL( aRepeatType, + CalenActionUiUtils::EDelete ); + } + else + { + doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL( + entryType == CCalEntry::ETodo ? + CalenActionUiUtils::EDeleteToDo : + CalenActionUiUtils::EDeleteEntry ); + } + + if( doDelete ) + { + //Before deleteing the entry reset the attachment model + if(iController.Services().GetAttachmentData()->NumberOfItems()) + { + iController.Services().GetAttachmentData()->Reset(); + } + + if( !TryDeleteWithMrUtilsL( aInstance, aRepeatType ) ) + { + 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 ); + } + } + } - if( !aHasRepeatType && ( child || repeating ) && - ( aInstance.type() != AgendaEntry::TypeAnniversary ) ) { - showRepeatingEntryDeleteQuery(); - } - else - { - showDeleteQuery(aInstance.type() == AgendaEntry::TypeTodo ? - EDeleteToDo : - EDeleteEntry ); - } - OstTraceFunctionExit0( CALENDELETEUI_DODELETESINGLEINSTANCEL_EXIT ); -} - + colIdArray.Reset(); + TRACE_EXIT_POINT; + return doDelete; + } // ----------------------------------------------------------------------------- -// CalenDeleteUi::DialogDismissedL +// 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 ) + { + //Before deleteing the attachment, reset the attachment model + if(iController.Services().GetAttachmentData()->NumberOfItems()) + { + iController.Services().GetAttachmentData()->Reset(); + } + aEntryView->DeleteL( *aEntry ); + + if( aEntry ) + { + delete aEntry; + aEntry = NULL; + } + } + + TRACE_EXIT_POINT; + return doDelete; + } + +// ----------------------------------------------------------------------------- +// CCalenDeleteUi::TryDeleteWithMrUtilsL +// Attempt to delete the instance using the Meeting Request utilities, +// if MR viewers is enabled. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TBool CCalenDeleteUi::TryDeleteWithMrUtilsL( CCalInstance* aInstance, + CalCommon::TRecurrenceRange aRepeatType ) + { + TRACE_ENTRY_POINT; + + TBool doDelete = ETrue; + + if( iGlobalData->InterimUtilsL().MRViewersEnabledL() && + iGlobalData->InterimUtilsL().IsMeetingRequestL(aInstance->Entry())) + + { + 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; + } + + TRACE_EXIT_POINT; + return doDelete; + } + +// ----------------------------------------------------------------------------- +// CCalenDeleteUi::ShowMultipleEntriesDeleteQueryL +// For displaying multiple entries deletion confirmation query +// ----------------------------------------------------------------------------- +// +TInt CCalenDeleteUi::ShowMultipleEntriesDeleteQueryL(TInt 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 ); + } + else if( aCount == 1 ) + { + resID = R_CALEN_QTN_TODO_QUEST_DELETE_MARKED_NOTE; + prompt = StringLoader::LoadLC( resID ); + } + 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 // From MProgressDialogCallback // Callback method // called when a dialog is dismissed. // ----------------------------------------------------------------------------- // -void CalenDeleteUi::DialogDismissedL( const TInt /*aButtonId*/ ) +void CCalenDeleteUi::DialogDismissedL( const TInt /*aButtonId*/ ) { - OstTraceFunctionEntry0( CALENDELETEUI_DIALOGDISMISSEDL_ENTRY ); + TRACE_ENTRY_POINT; + // dismiss the wait dialog + if(iWaitDialog) + { + iWaitDialog->ProcessFinishedL(); + } // no more entries to delete iMoreEntriesToDelete = EFalse; @@ -935,49 +1083,136 @@ // issue notification cancel delete iController.BroadcastNotification(ECalenNotifyCancelDelete); - - OstTraceFunctionExit0( CALENDELETEUI_DIALOGDISMISSEDL_EXIT ); + TRACE_EXIT_POINT; } // ----------------------------------------------------------------------------- -// CalenDeleteUi::DeleteEntryL +// CCalenDeleteUi::DeleteEntryL // Delete entry using entry local uid // ----------------------------------------------------------------------------- // -void CalenDeleteUi::DeleteEntryL(ulong& aEntryLocalUid) +void CCalenDeleteUi::DeleteEntryL(TCalLocalUid& aEntryLocalUid, TInt aColId) { - OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRYL_ENTRY ); + TRACE_ENTRY_POINT; - iController.Services().agendaInterface()->deleteEntry(aEntryLocalUid); + // 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; + } - OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRYL_EXIT ); + TRACE_EXIT_POINT; } // ----------------------------------------------------------------------------- -// CalenDeleteUi::DisplayWaitDialogL +// CCalenDeleteUi::DisplayWaitDialogL // Display wait dialog // ----------------------------------------------------------------------------- // -void CalenDeleteUi::DisplayWaitDialogL() +void CCalenDeleteUi::DisplayWaitDialogL() { - OstTraceFunctionEntry0( CALENDELETEUI_DISPLAYWAITDIALOGL_ENTRY ); + TRACE_ENTRY_POINT; - OstTraceFunctionExit0( CALENDELETEUI_DISPLAYWAITDIALOGL_EXIT ); + 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_EXIT_POINT; } // ----------------------------------------------------------------------------- -// CalenDeleteUi::MarkedEntriesDeletedL +// CCalenDeleteUi::MarkedEntriesDeletedL // Dismiss wait dialog and show information note // ----------------------------------------------------------------------------- // -void CalenDeleteUi::MarkedEntriesDeletedL() +void CCalenDeleteUi::MarkedEntriesDeletedL() { - OstTraceFunctionEntry0( CALENDELETEUI_MARKEDENTRIESDELETEDL_ENTRY ); + 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 ); + // notify marked entries deleted iController.BroadcastNotification( ECalenNotifyMarkedEntryDeleted ); - OstTraceFunctionExit0( CALENDELETEUI_MARKEDENTRIESDELETEDL_EXIT ); + 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