FCL/sf/app/organizer: comparison calendarui/controller/src/calendeleteui.cpp

equal deleted inserted replaced

-:f979ecb2b13e
+:c198609911f9
 /*
-* 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"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Description:  Handles deletion
 *
 */
+// System includes
-// INCLUDES
+#include <QString>
-#include <Calendar.rsg>
+#include <QtGui>
-#include <calendateutils.h>
+#include <hbdatetimepicker.h>
-#include <calenagendautils.h>
+#include <hbdialog.h>
-#include <aknnotewrappers.h>
+#include <hbaction.h>
-#include <AknWaitDialog.h>
+#include <hblabel.h>
-#include <calcommon.h>
+#include <hbradiobuttonlist.h>
-#include <calentryview.h>
-#include <calinstance.h>
-#include <calinstanceview.h>
-#include <caltime.h>
 #include <centralrepository.h>
-#include <eikenv.h>
+#include <agendaentry.h>
-#include <StringLoader.h>
-#include <sysutil.h>
+// User includes
-#include <calenglobaldata.h>
+#include "calendarui_debug.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 "calendarui_debug.h"           // Debug
 #include "calendeleteui.h"
+#include "hb_calencommands.hrh"
+#include "calencontext.h"
 #include "calencontroller.h"
 #include "CleanupResetAndDestroy.h"
-#include "CalenInterimUtils2.h"
+#include "caleninstanceid.h"
-#include "CalendarPrivateCRKeys.h"      // For CalendarInternalCRKeys.h
+#include "calenactionuiutils.h"
-#include "calenmultipledbmanager.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 );
 TRACE_EXIT_POINT;
 return self;
 }
 // ----------------------------------------------------------------------------
-// CCalenDeleteUi::CCalenDeleteUi
+// CalenDeleteUi::CalenDeleteUi
 // ?implementation_description
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-CCalenDeleteUi::CCalenDeleteUi( CCalenController& aController )
+CalenDeleteUi::CalenDeleteUi( CCalenController& aController, QObject *parent )
-: iEikEnv( CEikonEnv::Static() ), iController( aController )
+:QObject(parent), iController( aController )
 {
 TRACE_ENTRY_POINT;
-TRACE_EXIT_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 )
+TRACE_EXIT_POINT;
-{
+}
-delete iWaitDialog;
-iWaitDialog = NULL;
+// ----------------------------------------------------------------------------
-}
+// CalenDeleteUi::ConstructL
-if( iGlobalData )
-{
-iGlobalData->Release();
-}
-if( iDelAllRange )
-delete iDelAllRange;
-iDeleteColIds.Reset();
-TRACE_EXIT_POINT;
-}
-// ----------------------------------------------------------------------------
-// CCalenDeleteUi::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;
-TRACE_EXIT_POINT;
+}
-}
+// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+// CalenDeleteUi::HandleNotification
-// 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
 // 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();
+context.resetMultipleContextIds();
+}
+}
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CalenDeleteUi::HandleCommandL
+// Handles action ui commands
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TBool CalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand )
+{
+TRACE_ENTRY_POINT;
+TBool continueCommand(EFalse);
+switch( aCommand.Command() )
+{
+case ECalenDeleteCurrentEntry:
-// dismiss the waitdialog
+DeleteCurrentEntryL(); // Entry & instance
-if(iWaitDialog)
+break;
-{
-TRAP_IGNORE(iWaitDialog->ProcessFinishedL());
+case ECalenDeleteSeries:
-}
+DeleteThisOrAllL( AgendaUtil::ThisAndAll );
+break;
+case ECalenDeleteCurrentOccurrence:
+DeleteThisOrAllL( AgendaUtil::ThisOnly );
+break;
+case ECalenDeleteEntryWithoutQuery:
+continueCommand = DeleteEntryWithoutQueryL();
+break;
+case ECalenDeleteAllEntries:
+DeleteAllEntriesL(); // 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;
+}
+TRACE_EXIT_POINT;
+return continueCommand;
+}
+// ----------------------------------------------------------------------------
+// CalenDeleteUi::DeleteThisOrAllL
+// Deletes series repeating entry
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CalenDeleteUi::DeleteThisOrAllL( AgendaUtil::RecurrenceRange aRepeatType )
+{
+TRACE_ENTRY_POINT;
+bool isDeleted( false );
+if( iController.context().instanceId().mEntryLocalUid )
+{
+AgendaEntry instance =
+CalenActionUiUtils::findPossibleInstanceL(iController.context().instanceId(),
+iController.Services().agendaInterface() );
+if( !instance.isNull() )
+{
+isDeleted = DeleteSingleInstanceL( instance, aRepeatType );
 }
 }
-TRACE_EXIT_POINT;
-}
-// ----------------------------------------------------------------------------
-// CCalenDeleteUi::HandleCommandL
-// Handles action ui commands
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-TBool CCalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand )
-{
-TRACE_ENTRY_POINT;
-TBool continueCommand(EFalse);
-RArray<TInt> colArray;
-iController.GetActiveCollectionidsL(colArray);
-if( colArray.Count() && !( iGlobalData->InstanceViewL(colArray) ) )
-{
-iStoredCommand = aCommand;
-}
-else
-{
-switch( aCommand.Command() )
-{
-case ECalenDeleteCurrentEntry:
-DeleteCurrentEntryL(); // Entry & instance
-break;
-case ECalenDeleteSeries:
-DeleteThisOrAllL( CalCommon::EThisAndAll );
-break;
-case ECalenDeleteCurrentOccurrence:
-DeleteThisOrAllL( CalCommon::EThisOnly );
-break;
-case ECalenDeleteEntryWithoutQuery:
-continueCommand = DeleteEntryWithoutQueryL();
-break;
-case ECalenDeleteAllEntries:
-HandleDeleteAllEntriesL();
-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;
-}
-}
-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
-// Deletes series repeating entry
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CCalenDeleteUi::DeleteThisOrAllL( CalCommon::TRecurrenceRange aRepeatType )
-{
-TRACE_ENTRY_POINT;
-TBool isDeleted( EFalse );
-RArray<TInt> 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;
 }
 // ----------------------------------------------------------------------------
-// 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 );
 	    if(!iMoreEntriesToDelete)
 		    {
 			if(!iMoreEntriesToDelete)
 			    {
 			    DisplayWaitDialogL();
 			    }
 			// get the multiple context instance ids
-			RArray<TCalenInstanceId>& multipleContextIds = context.GetMutlipleContextIds();
+			QList<TCalenInstanceId>& multipleContextIds = context.getMutlipleContextIds();
 			if(iMutlipleContextIdsCount <= iEntriesToDelete )
 			    {
 			    iMoreEntriesToDelete = EFalse;
 			    iEntriesToDelete = iMutlipleContextIdsCount;
 			TInt index(0);
 			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++;
 			   }
 			if(!iMoreEntriesToDelete)
 			    {
 			    MarkedEntriesDeletedL();
 			    }
 			}
 else
 {
-context.ResetMultipleContextIds();
+context.resetMultipleContextIds();
 // notify delete failed
 iController.BroadcastNotification(ECalenNotifyDeleteFailed);
 }
 TRACE_EXIT_POINT;
 return continueCommand;
 }
 // ----------------------------------------------------------------------------
-// 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 (iController.context().instanceId().mEntryLocalUid) {
-{
+// Fetch the entry
-//If todo, use the LUid.
+AgendaEntry entry = iController.Services().agendaInterface()->fetchById(
-//Todos returns the current time if start or end time has not been saved.
+iController.context().instanceId().mEntryLocalUid);
-if( CCalEntry::ETodo == iGlobalData->Context().InstanceId().iType )
-{
+// Check if the entry is a To-Do
-CCalEntry* entry = iGlobalData->EntryViewL(iGlobalData->Context().InstanceId().iColId)->FetchL(
+if (AgendaEntry::TypeTodo == entry.type()) {
-iGlobalData->Context().InstanceId().iEntryLocalUid );
+if(!entry.isNull()) {
+deleted = DeleteEntryL(entry);
-if( entry )
+if(deleted) {
-{
+// Delete is successful
-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
+}
-{
+else {
-RArray<TInt> colIdArray;
+if (entry.isRepeating() || !entry.recurrenceId().isNull()) {
-colIdArray.AppendL(iGlobalData->Context().InstanceId().iColId);
+// Show a confirmation note whether the user
+// wants to delete the single instance or all of them
-CCalInstance* instance = CalenActionUiUtils::FindPossibleInstanceL(
+showRepeatingEntryDeleteQuery();
-iGlobalData->Context().InstanceId(),
+} else {
-*iGlobalData->InstanceViewL(colIdArray) );
+// If the entry is not a repeating entry,
-// if we have instance we will do delete other wise just return
+// delete it directly
-if( instance )
+deleted = DeleteEntryL(entry);
-{
+if (deleted) {
-// Note: ownership handling of instance is dirty in this case,
+// Delete is successful
-// 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;
-			}
-}
 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(
+const int buttonId = CalenActionUiUtils::showDeleteConfirmationQueryL(
 CalenActionUiUtils::EDeleteAll );
 if( buttonId )
 {
-HandleDeleteMultipleEventsL( TCalTime::MinTime(), TCalTime::MaxTime(),
+HandleDeleteMultipleEventsL( AgendaUtil::minTime(), AgendaUtil::maxTime(),1 );
-R_QTN_CALE_CONF_ALL_NOTES_DELETED );
 }
 else
 {
 // notify delete failed
 iController.BroadcastNotification(ECalenNotifyDeleteFailed);
 TRACE_EXIT_POINT;
 }
 // ----------------------------------------------------------------------------
-// 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();
+TCalenNotification notification = ECalenNotifyDeleteFailed;
-TTime today = date;
+// launch the datepicker
-TBool execute( EFalse );
+mIsDateValid = false;
-TBool exit( ETrue );
+dateQuery();
-do{
-exit = ETrue;
+if( mIsDateValid )
-execute = EFalse;
+{
+// Do delete only if inputted day is after beginning of range
-TInt buttonId = CalenActionUiUtils::DateQueryL(date, R_CALEN_DEL_BEFORE_DATE_PROMPT);
+if( mDateTime > AgendaUtil::minTime() )
-if( buttonId == EAknSoftkeyOk || buttonId == EEikBidOk )
 {
-execute = ETrue;
+// Two pass delete:
-if( today < date )
+// 1. pass
-{
+// To prevent destroying entries starting and ending midnight
-CAknNoteDialog* dialog = new( ELeave ) CAknNoteDialog(
+// subtract one microsecond and do delete on that range.
-CAknNoteDialog::EConfirmationTone,
+QTime time = mDateTime.time();
-CAknNoteDialog::ELongTimeout );
+time.setHMS(time.hour(), time.minute(), time.second(), time.msec() - 1);
-dialog->ExecuteLD( R_CALEN_DELETEERROR_NOTE );
+mDateTime.setTime(time);
-execute = EFalse;
+mDateTime = ( mDateTime > AgendaUtil::minTime()? mDateTime :  AgendaUtil::minTime());
-exit = EFalse;
-}
+HandleDeleteMultipleEventsL( AgendaUtil::minTime(),
+mDateTime,1 );
+notification = ECalenNotifyMultipleEntriesDeleted;
 }
-}while( !exit );
+}
-// Do delete only if inputted day is after beginning of range
+iController.BroadcastNotification( notification );
-if( execute && date > TCalTime::MinTime() )
+TRACE_EXIT_POINT;
-{
+}
-// Two pass delete:
-// 1. pass
+void CalenDeleteUi::dateQuery()
-// To prevent destroying entries starting and ending midnight
+	{
-// subtract one microsecond and do delete on that range.
+	// Create a popup with datepicker to select the date.
-date -= TTimeIntervalMicroSeconds32( 1 );
+	QDateTime currentDateTime(CalenDateUtils::today());
-date = Max( date, TCalTime::MinTime() );
+	QDate currentDate(currentDateTime.date());
+	mDatePicker = new  HbDateTimePicker(currentDate);
-HandleDeleteMultipleEventsL( TCalTime::MinTime(),
+	mDatePicker->setMinimumDate(CalenDateUtils::minTime().date());
-date,
+	mDatePicker->setMaximumDate(currentDate);
-R_QTN_CALE_CONF_PAST_NOTE_DELETED );
+	HbDialog popUp;
-}
+	popUp.setDismissPolicy(HbDialog::NoDismiss);
-else
+	popUp.setTimeout(HbDialog::NoTimeout );
-{
+	popUp.setHeadingWidget(new HbLabel(hbTrId("txt_calendar_title_set_date")));
-iController.BroadcastNotification( ECalenNotifyDeleteFailed );
+	popUp.setContentWidget(mDatePicker);
-}
+	HbAction *okAction = new HbAction(hbTrId("txt_calendar_button_dialog_delete"));
+	popUp.setPrimaryAction(okAction);
-TRACE_EXIT_POINT;
+	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();
-// CCalenDeleteUi::HandleDeleteMultipleEventsL
+	}
+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)));
+}
+// ----------------------------------------------------------------------------
+// CalenDeleteUi::HandleDeleteMultipleEventsL
 // Handles multiple delete events
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CCalenDeleteUi::HandleDeleteMultipleEventsL( const TTime& aFirstDay,
+void CalenDeleteUi::HandleDeleteMultipleEventsL( const QDateTime& aFirstDay,
-const TTime& aLastDay,
+const QDateTime& aLastDay,
-TInt aConfNoteId )
+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,
+void CalenDeleteUi::DeleteDayRangeL( const QDateTime& aStart,
-const TTime& aEnd )
+const QDateTime& aEnd )
 {
 TRACE_ENTRY_POINT;
 iStartTime = aStart;
 iEndTime = aEnd;
-TCalTime start, end;
+iIsDeleting = ETrue;
-start.SetTimeLocalL( iStartTime );
-end.SetTimeLocalL( iEndTime );
+//AgendaUtil& agendaInterface = iController.agendaInterface();
+// Connect to the signal that gets generated when deletion is completed
-if( iDelAllRange )
+connect(iController.agendaInterface(), SIGNAL(entriesDeleted(int)), this,
-{
+SLOT(doCompleted(int)));
-delete iDelAllRange;
+// 1: First pass, delete all entries.
-iDelAllRange = NULL;
+iController.agendaInterface()->deleteEntries(iStartTime, iEndTime);
-}
+TRACE_EXIT_POINT;
-iDelAllRange = new(ELeave) CalCommon::TCalTimeRange( start, end );
+}
-iDeleteColIds.Reset();
+// ----------------------------------------------------------------------------
-iIsDeleting = ETrue;
+// CalenDeleteUi::DoCompletedL
-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
-// (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 CCalenDeleteUi::DoCompletedL( TInt aFirstPassError )
+void CalenDeleteUi::doCompleted( int aFirstPassError )
 {
 TRACE_ENTRY_POINT;
-iToShowDeleteNote++;
-if(iNumberOfCalendars == iToShowDeleteNote)
+if( aFirstPassError == KErrNone )
 {
-	    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
-	        // 2: Second pass, delete notes that end 00:00 of next day of iEndTime
+QDateTime nextMidnight = CalenDateUtils::beginningOfDay( iEndTime.addDays(1) );
-	        // We didn't delete them in first pass
+nextMidnight = ( nextMidnight < AgendaUtil::maxTime()? nextMidnight : AgendaUtil::maxTime() );
-	        TTime nextMidnight = CalenDateUtils::BeginningOfDay( iEndTime + TTimeIntervalDays( 1 ) );
+PIM_TRAPD_HANDLE( deleteEntriesEndingAtMidnight( nextMidnight ) );
-	        nextMidnight = Min( nextMidnight, TCalTime::MaxTime() );
+}
-	        PIM_TRAPD_HANDLE( DeleteEntriesEndingAtMidnightL( nextMidnight ) );
-	        }
+// 3. End deleting, close wait dialog, and show confirmation or error note
+iIsDeleting = EFalse;
-		// 3. End deleting, close wait dialog, and show confirmation or error note
-		iIsDeleting = EFalse;
+iController.BroadcastNotification( ECalenNotifyMultipleEntriesDeleted );
-		iToShowDeleteNote = 0;
-		// dismiss the waitdialog
+TRACE_EXIT_POINT;
-		if(iWaitDialog)
+}
-			{
-			TRAP_IGNORE(iWaitDialog->ProcessFinishedL());
+// ----------------------------------------------------------------------------
-			}
+// CalenDeleteUi::DeleteEntriesEndingAtMidnightL
-		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 );
-}
-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 )
+void CalenDeleteUi::deleteEntriesEndingAtMidnight( QDateTime aMidnight )
 {
 TRACE_ENTRY_POINT;
-TCalTime start, end;
+QDateTime start, end;
-start.SetTimeLocalL( aMidnight - TTimeIntervalMinutes(1) );
+QTime startTime(aMidnight.time());
-end.SetTimeLocalL( aMidnight );
+startTime.setHMS(startTime.hour(), startTime.minute() - 1,
-CalCommon::TCalTimeRange midnightRange( start, end );
+startTime.second(), startTime.msec());
+start.setDate(aMidnight.date());
-RArray<TInt> colIdArray;
+start.setTime(startTime);
-iController.GetActiveCollectionidsL(colIdArray);
+end = aMidnight;
-// 1: Find instances falling on midnight moment
-RPointerArray< CCalInstance > instances;
+QList<AgendaEntry> instances = iController.Services().agendaInterface()->fetchEntriesInRange( start, end );
-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 )
+for( int i=0; i < instances.count(); ++i )
 {
-CCalInstance* item = instances[i];
+AgendaEntry entry = 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 ) )
+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( item->Entry().EndTimeL().TimeLocalL() == aMidnight )
+if( entry.endTime() == aMidnight )
 {
-iGlobalData->InstanceViewL(colIdArray)->DeleteL( item, CalCommon::EThisOnly );
+iController.Services().agendaInterface()->deleteRepeatedEntry(entry, AgendaUtil::ThisAndAll);
-// Ownership was transferred to DeleteL.
-// Put null to array to prevent double-deletion
-instances[i] = NULL;
 }
 }
-colIdArray.Reset();
+}
-}
-CleanupStack::PopAndDestroy( &instances );
+TRACE_EXIT_POINT;
+}
-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).
 // -----------------------------------------------------------------------------
 //
-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,
+TBool CalenDeleteUi::DeleteSingleInstanceL( AgendaEntry& aInstance,
-CalCommon::TRecurrenceRange aRepeatType )
+AgendaUtil::RecurrenceRange aRepeatType )
 {
 TRACE_ENTRY_POINT;
 TRACE_EXIT_POINT;
 return DoDeleteSingleInstanceL( aInstance, ETrue, aRepeatType );
 }
 // -----------------------------------------------------------------------------
-// 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
 // whether to delete the instance or the entire series.
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
-TBool CCalenDeleteUi::DoDeleteSingleInstanceL( CCalInstance* aInstance,
+TBool CalenDeleteUi::DoDeleteSingleInstanceL( AgendaEntry& aInstance,
-TBool aHasRepeatType,
+bool aHasRepeatType,
-CalCommon::TRecurrenceRange aRepeatType )
+AgendaUtil::RecurrenceRange aRepeatType )
 {
 TRACE_ENTRY_POINT;
-CCalEntry& entry = aInstance->Entry();
+bool repeating = aInstance.isRepeating();
-const CCalEntry::TType entryType = entry.EntryTypeL();
-RArray<TInt> colIdArray;
-colIdArray.AppendL(aInstance->InstanceIdL().iCollectionId);
-TCalRRule rrule;
-TBool repeating = entry.GetRRuleL( rrule );
 if( !repeating )
 {
 // Even though there is no RRule, the entry might
 // have a list of rdates.
-RArray< TCalTime > rDateArray;
+QList<QDate> rDates = aInstance.rDates();
-CleanupClosePushL( rDateArray );
+repeating = ( rDates.count() > 0 );
-entry.GetRDatesL( rDateArray );
+}
-repeating = ( rDateArray.Count() > 0 );
+QDateTime recId = aInstance.recurrenceId().toUTC();
-CleanupStack::PopAndDestroy(); // rDateArray
+const bool child = recId.isNull();
-}
-const TBool child = entry.RecurrenceIdL().TimeUtcL() != Time::NullTTime();
 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,
+//doDelete = CalenActionUiUtils::ShowRepeatTypeQueryL( aRepeatType,
-CalenActionUiUtils::EDelete );
+//                                                 CalenActionUiUtils::EDelete );
 }
 else
 {
-doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL(
+doDelete = CalenActionUiUtils::showDeleteConfirmationQueryL(aInstance.type() == AgendaEntry::TypeTodo ?
-entryType == CCalEntry::ETodo ?
 CalenActionUiUtils::EDeleteToDo :
 CalenActionUiUtils::EDeleteEntry );
 }
 if( doDelete )
 {
-if( !TryDeleteWithMrUtilsL( aInstance, aRepeatType ) )
+if( !child || aRepeatType == AgendaUtil::ThisOnly )
 {
-if( !child || aRepeatType == CalCommon::EThisOnly )
+iController.Services().agendaInterface()->deleteRepeatedEntry( aInstance, aRepeatType );
-{
-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 );
-}
 }
-}
+else if( aRepeatType == AgendaUtil::ThisAndAll )
+{
-colIdArray.Reset();
+iController.Services().agendaInterface()->deleteRepeatedEntry( aInstance, aRepeatType );
+}
+}
 TRACE_EXIT_POINT;
 return doDelete;
 }
 // -----------------------------------------------------------------------------
-// CCalenDeleteUi::DeleteEntryL
+// CalenDeleteUi::DeleteEntryL
 // Deletes an entry from the database
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
-TBool CCalenDeleteUi::DeleteEntryL( CCalEntryView* aEntryView, CCalEntry* aEntry )
+TBool CalenDeleteUi::DeleteEntryL( AgendaEntry& entry )
 {
 TRACE_ENTRY_POINT;
-const CCalEntry::TType entryType = aEntry->EntryTypeL();
+TBool doDelete = CalenActionUiUtils::showDeleteConfirmationQueryL(entry.type() == AgendaEntry::TypeTodo ?
-TBool doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL(
+CalenActionUiUtils::EDeleteToDo :
-entryType == CCalEntry::ETodo ?
+CalenActionUiUtils::EDeleteEntry );
-CalenActionUiUtils::EDeleteToDo :
-CalenActionUiUtils::EDeleteEntry );
 if( doDelete )
 {
-aEntryView->DeleteL( *aEntry );
+iController.Services().agendaInterface()->deleteEntry(entry.id());
-if( aEntry )
-{
-delete aEntry;
-aEntry = NULL;
-}
 }
 TRACE_EXIT_POINT;
 return doDelete;
 }
 // -----------------------------------------------------------------------------
-// CCalenDeleteUi::TryDeleteWithMrUtilsL
+// CalenDeleteUi::ShowMultipleEntriesDeleteQueryL
-// Attempt to delete the instance using the Meeting Request utilities,
+// For displaying multiple entries deletion confirmation query
-// if MR viewers is enabled.
+// -----------------------------------------------------------------------------
-// (other items were commented in a header).
+//
-// -----------------------------------------------------------------------------
+TInt CalenDeleteUi::ShowMultipleEntriesDeleteQueryL(int aCount)
-//
+	{
-TBool CCalenDeleteUi::TryDeleteWithMrUtilsL( CCalInstance* aInstance,
+TRACE_ENTRY_POINT;
-CalCommon::TRecurrenceRange aRepeatType )
+if( aCount > 1 )
 {
-TRACE_ENTRY_POINT;
+TRACE_EXIT_POINT;
+return CalenActionUiUtils::showDeleteConfirmationQueryL(CalenActionUiUtils::EDeleteToDos, aCount );
-TBool doDelete = ETrue;
+}
+else if( aCount ==  1 )
-	if( iGlobalData->InterimUtilsL().MRViewersEnabledL() &&
+{
-iGlobalData->InterimUtilsL().IsMeetingRequestL(aInstance->Entry()))
+TRACE_EXIT_POINT;
+return CalenActionUiUtils::showDeleteConfirmationQueryL(CalenActionUiUtils::EDeleteToDo);
-{
-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
+// 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;
 iDisplayQuery = EFalse;
 iController.BroadcastNotification(ECalenNotifyCancelDelete);
 TRACE_EXIT_POINT;
 }
 // -----------------------------------------------------------------------------
-// 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
+iController.Services().agendaInterface()->deleteEntry(aEntryLocalUid);
-CCalEntry* entry = iGlobalData->EntryViewL(aColId)->FetchL(aEntryLocalUid);
-if( entry )
+TRACE_EXIT_POINT;
-{
+}
-CleanupStack::PushL( entry );
-iGlobalData->EntryViewL(aColId)->DeleteL( *entry );
+// -----------------------------------------------------------------------------
-CleanupStack::Pop( entry );
+// CalenDeleteUi::DisplayWaitDialogL
-delete entry;
-entry = NULL;
-}
-TRACE_EXIT_POINT;
-}
-// -----------------------------------------------------------------------------
-// CCalenDeleteUi::DisplayWaitDialogL
 // Display wait dialog
 // -----------------------------------------------------------------------------
 //
-void CCalenDeleteUi::DisplayWaitDialogL()
+void CalenDeleteUi::DisplayWaitDialogL()
 {
 TRACE_ENTRY_POINT;
+TRACE_EXIT_POINT;
-delete iWaitDialog;
+}
-iWaitDialog = NULL;
-iWaitDialog = new( ELeave )CAknWaitDialog( REINTERPRET_CAST( CEikDialog**, &iWaitDialog ), ETrue );
+// -----------------------------------------------------------------------------
-iWaitDialog->ExecuteLD( R_TODO_VIEW_DELETE_WAIT_NOTE );
+// CalenDeleteUi::MarkedEntriesDeletedL
-iWaitDialog->SetCallback(this);
-TRACE_EXIT_POINT;
-}
-// -----------------------------------------------------------------------------
-// CCalenDeleteUi::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 );
 // 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

changeset 18	c198609911f9
parent 0	f979ecb2b13e
child 23	fd30d51f876b