--- 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 <Calendar.rsg>
-#include <calendateutils.h>
-#include <calenagendautils.h>
-#include <aknnotewrappers.h>
-#include <AknWaitDialog.h>
-#include <calcommon.h>
-#include <calentryview.h>
-#include <calinstance.h>
-#include <calinstanceview.h>
-#include <caltime.h>
+// System includes
+#include <QString>
+#include <QtGui>
+#include <hbdatetimepicker.h>
+#include <hbdialog.h>
+#include <hbaction.h>
+#include <hblabel.h>
+#include <hbradiobuttonlist.h>
#include <centralrepository.h>
-#include <eikenv.h>
-#include <StringLoader.h>
-#include <sysutil.h>
-#include <calenglobaldata.h>
-#include <calrrule.h>
-#include <calsession.h>
-#include <calencommands.hrh> // Calendar commands
-#include <calencontext.h>
-#include <caleninstanceid.h> // TCalenInstanceId
-#include <calenactionuiutils.h>
-#include <calcalendarinfo.h>
+#include <agendaentry.h>
-#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<TInt> 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<TInt> 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<TInt> 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<TInt> 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<TCalenInstanceId>& multipleContextIds = context.GetMutlipleContextIds();
+ QList<TCalenInstanceId>& multipleContextIds = context.getMutlipleContextIds();
if(iMutlipleContextIdsCount <= iEntriesToDelete )
{
@@ -365,13 +256,13 @@
while(index<iEntriesToDelete)
{
// get the local uid of the entry through multiple context list
- TCalLocalUid entryLocalUid = multipleContextIds[0].iEntryLocalUid;
+ ulong entryLocalUid = multipleContextIds[0].mEntryLocalUid;
if(entryLocalUid)
{
- DeleteEntryL(entryLocalUid, multipleContextIds[0].iColId);
+ DeleteEntryL(entryLocalUid);
}
// remove mutliple context based on the instanceid
- context.RemoveMultipleContextId(multipleContextIds[0]);
+ context.removeMultipleContextId(multipleContextIds[0]);
index++;
}
@@ -382,7 +273,7 @@
}
else
{
- context.ResetMultipleContextIds();
+ context.resetMultipleContextIds();
// notify delete failed
iController.BroadcastNotification(ECalenNotifyDeleteFailed);
}
@@ -392,112 +283,73 @@
}
// ----------------------------------------------------------------------------
-// CCalenDeleteUi::DeleteCurrentEntryL
+// CalenDeleteUi::DeleteCurrentEntryL
// Deletes the current entry
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
-void CCalenDeleteUi::DeleteCurrentEntryL()
- {
+void CalenDeleteUi::DeleteCurrentEntryL()
+{
TRACE_ENTRY_POINT;
- TBool deleted( EFalse );
+ bool deleted( false );
TCalenNotification notification = ECalenNotifyDeleteFailed;
// 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 );
+ 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<TInt> 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<AgendaEntry> 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<TInt> 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<TInt> 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<TInt> 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<QDate> 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<CCalEntry> 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<CCalCalendarInfo> calendarInfoList;
- CleanupClosePushL(calendarInfoList);
- iController.Services().GetAllCalendarInfoL(calendarInfoList);
- TInt visibleCalendarsCount(0);
- for(TInt index=0;index<calendarInfoList.Count();index++)
- {
- if(calendarInfoList[index]->Enabled())
- {
- 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