calendarui/controller/src/calendeleteui.cpp
branchRCL_3
changeset 30 bd7edf625bdd
parent 29 12af337248b1
--- a/calendarui/controller/src/calendeleteui.cpp	Tue Aug 31 15:13:43 2010 +0300
+++ b/calendarui/controller/src/calendeleteui.cpp	Wed Sep 01 12:32:31 2010 +0100
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
@@ -15,233 +15,332 @@
 *
 */
 
-// System includes
-#include <QString>
-#include <QtGui>
-#include <hbdatetimepicker.h>
-#include <hbdialog.h>
-#include <hbmessagebox.h>
-#include <hbaction.h>
-#include <hblabel.h>
-#include <hbradiobuttonlist.h>
+
+// 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>
 #include <centralrepository.h>
-#include <agendaentry.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 <calentoolbar.h>
+#include <akntoolbar.h>
+#include <calenattachmentmodel.h>
 
-// User includes
-#include "calendarui_debug.h"
+#include "calendarui_debug.h"           // Debug
 #include "calendeleteui.h"
-#include "calencontext.h"
 #include "calencontroller.h"
 #include "CleanupResetAndDestroy.h"
-#include "caleninstanceid.h"
-#include "calenactionuiutils.h"
-#include "calendateutils.h"
-#include "calenagendautils.h"
-#include "OstTraceDefinitions.h"
-#ifdef OST_TRACE_COMPILER_IN_USE
-#include "calendeleteuiTraces.h"
-#endif
-
+#include "CalenInterimUtils2.h"
+#include "CalendarPrivateCRKeys.h"      // For CalendarInternalCRKeys.h
+#include "calenmultipledbmanager.h"
 
 // Local constants
 const TInt KEntriesToDelete = 1;
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::NewL
+// CCalenDeleteUi::NewL
 // Two phased constructor
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-CalenDeleteUi* CalenDeleteUi::NewL( CCalenController& aController )
+CCalenDeleteUi* CCalenDeleteUi::NewL( CCalenController& aController )
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_NEWL_ENTRY );
-    
-    CalenDeleteUi* self = new( ELeave ) CalenDeleteUi( aController, NULL );
+    TRACE_ENTRY_POINT;
+
+    CCalenDeleteUi* self = new( ELeave ) CCalenDeleteUi( aController );
     CleanupStack::PushL( self );
     self->ConstructL();
     CleanupStack::Pop( self );
 
-    OstTraceFunctionExit0( CALENDELETEUI_NEWL_EXIT );
+    TRACE_EXIT_POINT;
     return self;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::CalenDeleteUi
+// CCalenDeleteUi::CCalenDeleteUi
 // ?implementation_description
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-CalenDeleteUi::CalenDeleteUi( CCalenController& aController, QObject *parent )
-    :QObject(parent), iController( aController )
+CCalenDeleteUi::CCalenDeleteUi( CCalenController& aController )
+    : iEikEnv( CEikonEnv::Static() ), iController( aController )
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_CALENDELETEUI_ENTRY );
-    
-    iIsDeleting = false;
-    
-    OstTraceFunctionExit0( CALENDELETEUI_CALENDELETEUI_EXIT );
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::~CalenDeleteUi
+// CCalenDeleteUi::~CCalenDeleteUi
 // Destructor
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-CalenDeleteUi::~CalenDeleteUi()
+CCalenDeleteUi::~CCalenDeleteUi()
     {
-    OstTraceFunctionEntry0( DUP1_CALENDELETEUI_CALENDELETEUI_ENTRY );
+    TRACE_ENTRY_POINT;
+
+    if( iWaitDialog )
+        {
+        delete iWaitDialog;
+        iWaitDialog = NULL;
+        }
+
+    if( iGlobalData )
+        {
+        iGlobalData->Release();
+        }
+
+    if( iDelAllRange )
+        delete iDelAllRange;
+
+    iDeleteColIds.Reset();
     
-    OstTraceFunctionExit0( DUP1_CALENDELETEUI_CALENDELETEUI_EXIT );
+    TRACE_EXIT_POINT;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::ConstructL
+// CCalenDeleteUi::ConstructL
 // Second phase of construction
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenDeleteUi::ConstructL()
+void CCalenDeleteUi::ConstructL()
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_CONSTRUCTL_ENTRY );
+    TRACE_ENTRY_POINT;
+
+    iGlobalData = CCalenGlobalData::InstanceL();
+
+    // Both the entry view and instance views are needed
+    // by the deleteUi commands, there queue the construction of both
+    RArray<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;
-    
-    OstTraceFunctionExit0( CALENDELETEUI_CONSTRUCTL_EXIT );
+    iDelAllRange = NULL;
+    TRACE_EXIT_POINT;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::HandleNotification
+// CCalenDeleteUi::HandleECalenNotifyViewCreatedL
+// Handles ECalenNotifyViewCreated.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenDeleteUi::HandleECalenNotifyViewCreatedL()
+    {
+    TRACE_ENTRY_POINT;
+    RArray<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 CalenDeleteUi::HandleNotification(const TCalenNotification aNotification )
+void CCalenDeleteUi::HandleNotification(const TCalenNotification aNotification )
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_HANDLENOTIFICATION_ENTRY );
+    TRACE_ENTRY_POINT;
 
+    if ( aNotification == ECalenNotifyEntryInstanceViewCreated )
+        {
+        PIM_TRAPD_HANDLE( HandleECalenNotifyViewCreatedL() );
+        }
     if( aNotification == ECalenNotifyCancelDelete)
         {
         if(iMutlipleContextIdsCount)
             {
             // get the context
-            MCalenContext& context = iController.context();
+            MCalenContext& context = iGlobalData->Context();
             // reset the multiple contexts
-            context.resetMultipleContextIds();          
-           
+            context.ResetMultipleContextIds();
+            
+            // dismiss the waitdialog
+            if(iWaitDialog)
+                {
+                TRAP_IGNORE(iWaitDialog->ProcessFinishedL());
+                }
             }
         }
-    
-    OstTraceFunctionExit0( CALENDELETEUI_HANDLENOTIFICATION_EXIT );
+    TRACE_EXIT_POINT;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::HandleCommandL
+// CCalenDeleteUi::HandleCommandL
 // Handles action ui commands
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-TBool CalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand )
+TBool CCalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand )
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_HANDLECOMMANDL_ENTRY );
-    
+    TRACE_ENTRY_POINT;
     TBool continueCommand(EFalse);
     
-    switch( aCommand.Command() )
+    RArray<TInt> colArray;
+    iController.GetActiveCollectionidsL(colArray);
+    
+    if( colArray.Count() && !( iGlobalData->InstanceViewL(colArray) ) )
         {
-        case ECalenDeleteCurrentEntry:
-        	mDeleteCommand = ECalenDeleteCurrentEntry;
-        	DeleteCurrentEntryL(); // Entry & instance
-            break;
+        iStoredCommand = aCommand;
+        }
+    else
+        {
+        switch( aCommand.Command() )
+            {
+            case ECalenDeleteCurrentEntry:
+                DeleteCurrentEntryL(); // Entry & instance
+                break;
 
-        case ECalenDeleteSeries:
-        	mDeleteCommand = ECalenDeleteSeries;
-        	DeleteThisOrAllL( AgendaUtil::ThisAndAll );
-            break;
-            
-        case ECalenDeleteCurrentOccurrence:
-        	mDeleteCommand = ECalenDeleteCurrentOccurrence;
-        	DeleteThisOrAllL( AgendaUtil::ThisOnly );
-            break;
-            
-        case ECalenDeleteEntryWithoutQuery:
-        	//TODO:
-        	// This case is not handled currently as no such commands
-        	// has been issued. So this has to be handled once we start 
-        	// issuing the command. 
-        	/*continueCommand = DeleteEntryWithoutQueryL();*/
-            break;
+            case ECalenDeleteSeries:
+                DeleteThisOrAllL( CalCommon::EThisAndAll );
+                break;
+                
+            case ECalenDeleteCurrentOccurrence:
+                DeleteThisOrAllL( CalCommon::EThisOnly );
+                break;
+                
+            case ECalenDeleteEntryWithoutQuery:
+                continueCommand = DeleteEntryWithoutQueryL();
+                break;
 
-        case ECalenDeleteAllEntries:
-        	mDeleteCommand = ECalenDeleteAllEntries;
-        	DeleteAllEntriesL(); // EntryView & instance
-            break;
+            case ECalenDeleteAllEntries:
+                HandleDeleteAllEntriesL();
+                break;
 
-        case ECalenDeleteEntriesBeforeDate:
-            DeleteEntriesBeforeDateL(); // EntryView & instance
-            break;
+            case ECalenDeleteEntriesBeforeDate:
+                DeleteEntriesBeforeDateL(); // EntryView & instance
+                break;
 
-        default:
-            // Controller decided this class was the place to handle this
-            // command but it wasn't in our list; something has gone wrong.
-            //ASSERT( EFalse );
-            break;
+            default:
+                // Controller decided this class was the place to handle this
+                // command but it wasn't in our list; something has gone wrong.
+                //ASSERT( EFalse );
+                break;
+            }
         }
-        
-    OstTraceFunctionExit0( CALENDELETEUI_HANDLECOMMANDL_EXIT );
+    colArray.Reset();
+    TRACE_EXIT_POINT;
     return continueCommand;
     }
 
+// ----------------------------------------------------------------------------
+// CCalenDeleteUi::CalenCommandHandlerExtensionL
+// Dummy implementation.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TAny* CCalenDeleteUi::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ )
+    {
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    return NULL;
+    }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteThisOrAllL
+// CCalenDeleteUi::DeleteThisOrAllL
 // Deletes series repeating entry
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DeleteThisOrAllL( AgendaUtil::RecurrenceRange aRepeatType )
-{
-    OstTraceFunctionEntry0( CALENDELETEUI_DELETETHISORALLL_ENTRY );
-
-	if( iController.context().instanceId().mEntryLocalUid )
-	{
-		AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL(
-									iController.context().instanceId(),
-									iController.Services().agendaInterface() );
-		if( !instance.isNull() )
-		{
-			DeleteSingleInstanceL( instance, aRepeatType );
-		}
-	}
-	
-	OstTraceFunctionExit0( CALENDELETEUI_DELETETHISORALLL_EXIT );
-}
+void CCalenDeleteUi::DeleteThisOrAllL( CalCommon::TRecurrenceRange aRepeatType )
+    {
+    TRACE_ENTRY_POINT;
+    
+    TBool isDeleted( EFalse );
+    
+    RArray<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;
+    }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteEntryWithoutQueryL()
+// CCalenDeleteUi::DeleteEntryWithoutQueryL()
 // Deletes the current entry
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-TBool CalenDeleteUi::DeleteEntryWithoutQueryL()
+TBool CCalenDeleteUi::DeleteEntryWithoutQueryL()
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRYWITHOUTQUERYL_ENTRY );
-    
-	bool continueCommand(EFalse);
+    TRACE_ENTRY_POINT;
+	TBool continueCommand(EFalse);
     
 	// get the context
-	MCalenContext& context = iController.context();
+	MCalenContext& context = iGlobalData->Context();
 	
 	// get the multliple context ids count
-	iMutlipleContextIdsCount = context.mutlipleContextIdsCount();
+	iMutlipleContextIdsCount = context.MutlipleContextIdsCount();
 	
 	ASSERT( iMutlipleContextIdsCount );
 
 	    if(!iMoreEntriesToDelete)
 		    {
-		    //iDisplayQuery = ShowMultipleEntriesDeleteQueryL(iMutlipleContextIdsCount);
+		    iDisplayQuery = ShowMultipleEntriesDeleteQueryL(iMutlipleContextIdsCount);
 		    }
 		
 		if(iDisplayQuery)
@@ -251,7 +350,7 @@
 			    DisplayWaitDialogL();
 			    }
 			// get the multiple context instance ids
-			QList<TCalenInstanceId>& multipleContextIds = context.getMutlipleContextIds();
+			RArray<TCalenInstanceId>& multipleContextIds = context.GetMutlipleContextIds();
 			
 			if(iMutlipleContextIdsCount <= iEntriesToDelete )
 			    {
@@ -269,13 +368,13 @@
 			while(index<iEntriesToDelete)
 			    {
 			    // get the local uid of the entry through multiple context list
-			    ulong entryLocalUid = multipleContextIds[0].mEntryLocalUid;
+			    TCalLocalUid entryLocalUid = multipleContextIds[0].iEntryLocalUid;			    
 			    if(entryLocalUid)
 			        {
-			        DeleteEntryL(entryLocalUid);
+			        DeleteEntryL(entryLocalUid, multipleContextIds[0].iColId);
 			        }
 			    // remove mutliple context based on the instanceid
-			    context.removeMultipleContextId(multipleContextIds[0]);
+			    context.RemoveMultipleContextId(multipleContextIds[0]);
 			    index++;
 			   }
 
@@ -283,596 +382,458 @@
 			    {
 			    MarkedEntriesDeletedL();    
 			    }
+			MCalenToolbar* toolbarImpl = iController.Services().ToolbarOrNull(); 
+            if (toolbarImpl)
+                {
+                CAknToolbar& toolbar = toolbarImpl->Toolbar();
+    
+                // dim clear and clear all toolbar buttons
+                toolbar.SetItemDimmed(ECalenNewMeeting, EFalse, ETrue);
+                }
 			}
         else
             {
-            context.resetMultipleContextIds();
+            context.ResetMultipleContextIds();
             // notify delete failed
             iController.BroadcastNotification(ECalenNotifyDeleteFailed);    
             }
 	
-    OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRYWITHOUTQUERYL_EXIT );
+    TRACE_EXIT_POINT;
     return continueCommand;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteCurrentEntryL
+// CCalenDeleteUi::DeleteCurrentEntryL
 // Deletes the current entry
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DeleteCurrentEntryL()
-{
-    OstTraceFunctionEntry0( CALENDELETEUI_DELETECURRENTENTRYL_ENTRY );
+void CCalenDeleteUi::DeleteCurrentEntryL()
+    {
+    TRACE_ENTRY_POINT;
+
+    TBool deleted( EFalse );
+    TCalenNotification notification = ECalenNotifyDeleteFailed;
     
-	// Make sure we're focused on an entry.
-	if (iController.context().instanceId().mEntryLocalUid) {
-		// Fetch the entry
-		AgendaEntry entry = iController.Services().agendaInterface()->fetchById(
-				iController.context().instanceId().mEntryLocalUid);
-			// Check if the entry is a To-Do
-			if (AgendaEntry::TypeTodo == entry.type()) {
-				showDeleteQuery(EDeleteToDo);
-			} else {
-				// Show the repeat entry delete query for repeating entries except Anniversary
-				// Even though the anniversary is repeating 
-				// all the instances will be deleted
-				if ((entry.isRepeating() || !entry.recurrenceId().isNull()) 
-							&& (AgendaEntry::TypeAnniversary != entry.type())) {
-					// Show a confirmation note whether the user
-					// wants to delete the single instance or all of them
-					showRepeatingEntryDeleteQuery();
-				} else if (CalenAgendaUtils::isAlldayEvent(entry)) {
-					showDeleteQuery(EDeleteEvent);
-				} else {
-					// If the entry is not a repeating entry,
-					// delete it directly
-					// Save the entry for later reference in the slot
-					showDeleteQuery(EDeleteEntry);
-				}
+    // Make sure we're focused on an entry.
+    if( iGlobalData->Context().InstanceId().iEntryLocalUid )
+        {
+        //If todo, use the LUid.
+        //Todos returns the current time if start or end time has not been saved.
+        if( CCalEntry::ETodo == iGlobalData->Context().InstanceId().iType )
+            {
+            CCalEntry* entry = iGlobalData->EntryViewL(iGlobalData->Context().InstanceId().iColId)->FetchL(
+                                    iGlobalData->Context().InstanceId().iEntryLocalUid );
+
+            if( entry )
+                {
+                CleanupStack::PushL( entry );
+                deleted = DeleteEntryL( iGlobalData->EntryViewL(iGlobalData->Context().InstanceId().iColId), entry );
+
+                if( deleted )
+                    {
+                    CleanupStack::Pop( entry );
+                    notification = ECalenNotifyEntryDeleted;
+                    }
+                else
+                    {
+                    CleanupStack::PopAndDestroy( entry );
+                    }
+                }
+            }
+        else // Not todo
+            {
+            RArray<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 );
+                    notification = ECalenNotifyEntryDeleted;
+                    }
+                else
+                    {
+                    CleanupStack::PopAndDestroy( instance );
+                    }
+                }
+            colIdArray.Reset();
+            }
+        }
+    else
+        {
+         TBool doDelete( ETrue );
+         
+         doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL( 
+                                                                   iGlobalData->Context().InstanceId().iType == CCalEntry::ETodo ?
+                                                                   CalenActionUiUtils::EDeleteToDo :
+                                                                   CalenActionUiUtils::EDeleteEntry );
+		if ( doDelete )
+			{
+			notification = ECalenNotifyEntryDeleted;	
 			}
-	}
-	OstTraceFunctionExit0( CALENDELETEUI_DELETECURRENTENTRYL_EXIT );
-}
+        }
+        
+    iController.BroadcastNotification( notification );
+
+    TRACE_EXIT_POINT;
+    }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteAllEntriesL
+// CCalenDeleteUi::DeleteAllEntriesL
 // Deletes all entries
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DeleteAllEntriesL()
+void CCalenDeleteUi::DeleteAllEntriesL()
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DELETEALLENTRIESL_ENTRY );
-    
-	if(iIsDeleting) {
-		OstTraceFunctionExit0( CALENDELETEUI_DELETEALLENTRIESL_EXIT );
-		return;
-	}
+    TRACE_ENTRY_POINT;
+
+    ASSERT( !iIsDeleting );
+
+    const TInt buttonId = CalenActionUiUtils::ShowDeleteConfirmationQueryL( 
+                                           CalenActionUiUtils::EDeleteAll );
 
-    showDeleteQuery(EDeleteAll );
-	OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETEALLENTRIESL_EXIT );
-	}
+    if( buttonId )
+        {
+        HandleDeleteMultipleEventsL( TCalTime::MinTime(), TCalTime::MaxTime(),
+                                 R_QTN_CALE_CONF_ALL_NOTES_DELETED );
+        }
+    else
+        {
+        // notify delete failed
+        iController.BroadcastNotification(ECalenNotifyDeleteFailed); 
+        }
+
+    TRACE_EXIT_POINT;
+    }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteEntriesBeforeDateL
+// CCalenDeleteUi::DeleteEntriesBeforeDateL
 // Deletes all entries before a set date.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DeleteEntriesBeforeDateL()
+void CCalenDeleteUi::DeleteEntriesBeforeDateL()
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRIESBEFOREDATEL_ENTRY );
+    TRACE_ENTRY_POINT;
+
+    ASSERT( !iIsDeleting );
+    TTime date;
+    date.HomeTime();
+    TTime today = date;
+
+    TBool execute( EFalse );
+    TBool exit( ETrue );
+    do{
+        exit = ETrue;
+        execute = EFalse;
+
+        TInt buttonId = CalenActionUiUtils::DateQueryL(date, R_CALEN_DEL_BEFORE_DATE_PROMPT);
+
+        if( buttonId == EAknSoftkeyOk || buttonId == EEikBidOk )
+            {
+            execute = ETrue;
+            if( today < date )
+                {
+                CAknNoteDialog* dialog = new( ELeave ) CAknNoteDialog( 
+                                                            CAknNoteDialog::EConfirmationTone,
+                                                            CAknNoteDialog::ELongTimeout );
+                dialog->ExecuteLD( R_CALEN_DELETEERROR_NOTE );
+                execute = EFalse;
+                exit = EFalse;
+                }
+            }
+        }while( !exit );
+
+    // Do delete only if inputted day is after beginning of range
+    if( execute && date > TCalTime::MinTime() )
+        {
+        // Two pass delete:
+        // 1. pass
+        // To prevent destroying entries starting and ending midnight
+        // subtract one microsecond and do delete on that range.
+        date -= TTimeIntervalMicroSeconds32( 1 );
+        date = Max( date, TCalTime::MinTime() );
+
+        HandleDeleteMultipleEventsL( TCalTime::MinTime(),
+                                                date,
+                                               R_QTN_CALE_CONF_PAST_NOTE_DELETED );
+        }
+    else
+        {
+        iController.BroadcastNotification( ECalenNotifyDeleteFailed );
+        }
     
-	if(iIsDeleting) {
-		OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRIESBEFOREDATEL_EXIT );
-		return;
-	}    
-    // launch the datepicker
-    dateQuery();
-    OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETEENTRIESBEFOREDATEL_EXIT );
+    TRACE_EXIT_POINT;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::dateQuery
-// Launches the popup for the date selection
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenDeleteUi::dateQuery()
-	{
-    OstTraceFunctionEntry0( CALENDELETEUI_DATEQUERY_ENTRY );
-    
-	// Create a popup with datepicker to select the date.
-	HbDialog *popUp = new HbDialog();
-	popUp->setDismissPolicy(HbDialog::NoDismiss);
-	popUp->setTimeout(HbDialog::NoTimeout );
-	popUp->setAttribute( Qt::WA_DeleteOnClose, true );
-	popUp->setHeadingWidget(new HbLabel(hbTrId("txt_calendar_title_set_date")));
-	
-	QDateTime currentDateTime(CalenDateUtils::today());
-	QDate currentDate(currentDateTime.date());
-	if(mDatePicker) {
-		mDatePicker = NULL;
-	}
-	mDatePicker = new  HbDateTimePicker(popUp);
-	mDatePicker->setMinimumDate(CalenDateUtils::minTime().date());
-	mDatePicker->setMaximumDate(currentDate);
-	mDatePicker->setDate(currentDate);
-
-	popUp->setContentWidget(mDatePicker);  
-	mDeleteAction = new HbAction(
-						hbTrId("txt_common_button_delete"), popUp);
-	popUp->addAction(mDeleteAction);
-	mCancelAction = new HbAction(hbTrId("txt_common_button_cancel"),popUp);
-	popUp->addAction(mCancelAction);
-	// Show the popup
-	popUp->open(this, SLOT(handleDateQuery(HbAction*)));
-	
-	OstTraceFunctionExit0( CALENDELETEUI_DATEQUERY_EXIT );
-	}
-
-// ----------------------------------------------------------------------------
-// CalenDeleteUi::handleDateQuery
-// Handles the selection for the date query
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenDeleteUi::handleDateQuery(HbAction* action)
-{
-    OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDATEQUERY_ENTRY );
-    
-	if(action == mDeleteAction) {
-		// User selected the date before which all the entries has to be deleted
-		QDate selectedDate(mDatePicker->date());
-		// Check if the date is within the range.
-		if(selectedDate.isValid()) {
-			QTime time(0,0,0,0);
-			QDateTime dateTime;
-			dateTime.setDate(selectedDate);
-			dateTime.setTime(time);
-			// Do delete only if inputted day is after beginning of range
-			if(dateTime > AgendaUtil::minTime()) {
-				// Two pass delete:
-				// 1. pass
-				// To prevent destroying entries starting and ending midnight
-				// subtract one second and do delete on that range.
-				dateTime = dateTime.addSecs(-1);
-				dateTime = ( dateTime > AgendaUtil::minTime()? 
-											dateTime :  AgendaUtil::minTime());
-
-				HandleDeleteMultipleEventsL( AgendaUtil::minTime(), 
-																 dateTime, 1);
-			}else {
-				iController.BroadcastNotification(ECalenNotifyDeleteFailed);
-			}
-		}
-	}else {
-		// User pressed cancel
-		handleDeleteCancel();
-	}
-	// Reset the member variables
-	mDeleteAction = NULL;
-	mCancelAction = NULL;
-	
-	OstTraceFunctionExit0( CALENDELETEUI_HANDLEDATEQUERY_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenDeleteUi::showRepeatingEntryDeleteQuery
-// Launches the popup for deleting the repeating entry
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenDeleteUi::showRepeatingEntryDeleteQuery()
-{
-    OstTraceFunctionEntry0( CALENDELETEUI_SHOWREPEATINGENTRYDELETEQUERY_ENTRY );
-    
-    HbDialog *popUp = new HbDialog();
-    popUp->setDismissPolicy(HbDialog::NoDismiss);
-    popUp->setTimeout(HbDialog::NoTimeout);
-    popUp->setAttribute( Qt::WA_DeleteOnClose, true );
-    
-    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical);
-    HbWidget *editWidget = new HbWidget();
-    editWidget->setLayout(layout);
-    
-    HbRadioButtonList *editButtonList = new HbRadioButtonList();
-    
-    QStringList list;
-    list << hbTrId("txt_calendar_info_this_occurrence_only")
-    		<< hbTrId("txt_calendar_info_all_occurences");
-
-    editButtonList->setItems(list);
-
-    layout->addItem(editButtonList);
-    
-    popUp->setContentWidget(editWidget);
-    popUp->setHeadingWidget(new HbLabel(
-						hbTrId("txt_calendar_title_delete_repeated_entry")));
-
-    // Add cancel action
-    HbAction *cancelAction = new HbAction(
-							hbTrId("txt_common_button_cancel_singledialog"));
-    popUp->addAction(cancelAction);
-    connect(editButtonList, SIGNAL(itemSelected(int)), this,
-										SLOT(handleRepeatedEntryDelete(int)));
-    connect(editButtonList, SIGNAL(itemSelected(int)), popUp, SLOT(close()));
-    connect(cancelAction, SIGNAL(triggered()), this, 
-										SLOT(handleDeleteCancel()));
-    
-    // Show the popup
-    popUp->open();
-    
-    OstTraceFunctionExit0( CALENDELETEUI_SHOWREPEATINGENTRYDELETEQUERY_EXIT );
-}
-
-// ----------------------------------------------------------------------------
-// CalenDeleteUi::handleDeleteCancel
-// Handles the cancel action
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenDeleteUi::handleDeleteCancel()
-{
-    OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDELETECANCEL_ENTRY );
-    
-	iController.BroadcastNotification(ECalenNotifyDeleteFailed);
-	
-	OstTraceFunctionExit0( CALENDELETEUI_HANDLEDELETECANCEL_EXIT );
-}
-
-void CalenDeleteUi::handleRepeatedEntryDelete(int index)
-{
-    OstTraceFunctionEntry0( CALENDELETEUI_HANDLEREPEATEDENTRYDELETE_ENTRY );
-    
-	// Fetch the entry
-	// Find all possible instances
-	AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL(
-									iController.context().instanceId(),
-									iController.Services().agendaInterface());
-
-	if (!instance.isNull()) {
-		connect(iController.Services().agendaInterface(), 
-									SIGNAL(entryDeleted(ulong)),
-									this, SLOT(entryDeleted(ulong)));
-		switch(index) {
-			case 0:
-				// User wants to delete only this occurence
-				iController.Services().agendaInterface()->deleteRepeatedEntry(
-									instance, AgendaUtil::ThisOnly);
-				break;
-			case 1:
-				// User wants to delete all the occurences
-				iController.Services().agendaInterface()->deleteRepeatedEntry(
-									instance, AgendaUtil::ThisAndAll);
-				break;
-		}
-	}else {
-	    iController.BroadcastNotification(ECalenNotifyDeleteFailed);
-	}
-	OstTraceFunctionExit0( CALENDELETEUI_HANDLEREPEATEDENTRYDELETE_EXIT );
-}
-
-// ----------------------------------------------------------------------------
-// CalenDeleteUi::showDeleteQuery
-// Launches the popup for deleting the instance/instances
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenDeleteUi::showDeleteQuery(const TDeleteConfirmationType type,
-                                                     const int count)
-    {
-    OstTraceFunctionEntry0( CALENDELETEUI_SHOWDELETEQUERY_ENTRY );
-    
-    HbMessageBox *popup = new HbMessageBox(HbMessageBox::MessageTypeQuestion);
-    popup->setDismissPolicy(HbDialog::NoDismiss);
-    popup->setTimeout(HbDialog::NoTimeout);
-    popup->setAttribute( Qt::WA_DeleteOnClose, true );
-    
-    QString text = 0;
-    
-    switch(type)
-        {
-        case EDeleteEntry:
-            {
-            text.append(hbTrId("txt_calendar_info_delete_meeting"));
-            break;
-            }
-        case EDeleteToDo:
-            {
-            text.append(hbTrId("txt_calendar_info_delete_todo_note"));
-            break;
-            }
-        case EDeleteToDos:
-            {//"Delete %N to-do notes?"
-            // TODO: Add the text id
-            text.append("Delete %N to-do's?").arg(count);
-            break;
-            }
-        case EDeleteAll:
-            {
-            text.append(hbTrId("txt_calendar_info_delete_all_calendar_entries"));
-            break;
-            }
-        case EDeleteEvent:
-            {
-            text.append(hbTrId("txt_calendar_info_delete_allday_event"));
-            break;
-            }
-        default:
-            break;
-        }
-    
-    popup->setText(text);
-    	
-    QList<QAction*> list = popup->actions();
-    for(int i=0; i < list.count(); i++)
-        {
-        popup->removeAction(list[i]);
-        }
-    mDeleteAction = new HbAction(
-						hbTrId("txt_common_button_delete"), popup);
-    popup->addAction(mDeleteAction);
-    mCancelAction = new HbAction(hbTrId("txt_common_button_cancel"), popup); 
-    popup->addAction(mCancelAction);
-    popup->open(this, SLOT(handleDeletion(HbAction*)));
-    
-    OstTraceFunctionExit0( CALENDELETEUI_SHOWDELETEQUERY_EXIT );
-    }
-
-// ----------------------------------------------------------------------------
-// CalenDeleteUi::handleDeletion
-// Deletes the entries based on the user selection
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenDeleteUi::handleDeletion(HbAction* action)
-{
-    OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDELETION_ENTRY );
-    
-	TCalenNotification notification = ECalenNotifyDeleteFailed;
-	
-	if(action == mDeleteAction) {
-		
-		switch (mDeleteCommand) {
-			
-			case ECalenDeleteCurrentEntry:
-			{
-				// Get the entry id
-				ulong id = iController.context().instanceId().mEntryLocalUid;
-				connect(iController.Services().agendaInterface(), 
-												SIGNAL(entryDeleted(ulong)),
-												this, SLOT(entryDeleted(ulong)));
-				// Delete the entry if the delete button is been pressed
-				iController.Services().agendaInterface()->deleteEntry(id);
-			}
-				break;
-			
-			case ECalenDeleteSeries:
-			case ECalenDeleteCurrentOccurrence:
-			{
-				AgendaEntry instance = 
-						CalenActionUiUtils::findPossibleInstanceL(
-								iController.context().instanceId(),
-								iController.Services().agendaInterface() );
-				if(!instance.isNull()) {
-					QDateTime recId = instance.recurrenceId().toUTC();
-					const bool child = recId.isNull();
-					connect(iController.Services().agendaInterface(), 
-					        SIGNAL(entryDeleted(ulong)),
-					        this, SLOT(entryDeleted(ulong)));
-					if( !child || mRecurrenceRange == AgendaUtil::ThisOnly 
-							|| mRecurrenceRange == AgendaUtil::ThisAndAll) {
-						iController.Services().agendaInterface()->deleteRepeatedEntry( 
-								instance, mRecurrenceRange );
-					}
-				}else {
-				    iController.BroadcastNotification(ECalenNotifyDeleteFailed); 
-				}
-			}
-				break;
-			
-			case ECalenDeleteAllEntries:
-			{
-				HandleDeleteMultipleEventsL( AgendaUtil::minTime(), 
-											AgendaUtil::maxTime(),1 );
-			}
-				break;
-			
-			default:
-				break;
-				
-		}
-	} else {
-		// If the user presses cancel button the notification will be
-		// ECalenNotifyDeleteFailed as default.
-		// Notify the status
-		iController.BroadcastNotification(notification);
-	}
-	
-	// Reset the member variables
-	mDeleteAction = NULL;
-	mCancelAction = NULL;
-	
-	OstTraceFunctionExit0( CALENDELETEUI_HANDLEDELETION_EXIT );
-}
-
-void CalenDeleteUi::entryDeleted(ulong id)
-{
-    OstTraceFunctionEntry0( CALENDELETEUI_ENTRYDELETED_ENTRY );
-    
-    if (iController.context().instanceId().mEntryLocalUid == id) {
-        iController.BroadcastNotification(ECalenNotifyEntryDeleted);
-    }
-    disconnect(iController.Services().agendaInterface(), SIGNAL(entryDeleted(ulong)),
-               this, SLOT(entryDeleted(ulong)));
-    
-    OstTraceFunctionExit0( CALENDELETEUI_ENTRYDELETED_EXIT );
-}
-
-// ----------------------------------------------------------------------------
-// CalenDeleteUi::HandleDeleteMultipleEventsL
+// CCalenDeleteUi::HandleDeleteMultipleEventsL
 // Handles multiple delete events
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenDeleteUi::HandleDeleteMultipleEventsL( const QDateTime& aFirstDay,
-                                                 const QDateTime& aLastDay,
-                                                 int aConfNoteId )
+void CCalenDeleteUi::HandleDeleteMultipleEventsL( const TTime& aFirstDay,
+                                                                     const TTime& aLastDay,
+                                                                     TInt /*aConfNoteId */)
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDELETEMULTIPLEEVENTSL_ENTRY );
-    
-	if(iIsDeleting) {
-		OstTraceFunctionExit0( CALENDELETEUI_HANDLEDELETEMULTIPLEEVENTSL_EXIT );
-		return;
-	}
-    iConfirmationNoteId = aConfNoteId;
-    
+    TRACE_ENTRY_POINT;
+
+    ASSERT( !iWaitDialog );
+    ASSERT( !iIsDeleting );
+    //iConfirmationNoteId = aConfNoteId;
+
+    iWaitDialog = new( ELeave ) CAknWaitDialog( REINTERPRET_CAST( CEikDialog**, 
+                                                                  &iWaitDialog ) );
+    iWaitDialog->ExecuteLD( R_CALEN_DELETE_WAIT_NOTE );
+
     DeleteDayRangeL( aFirstDay, aLastDay );
 
-    OstTraceFunctionExit0( DUP1_CALENDELETEUI_HANDLEDELETEMULTIPLEEVENTSL_EXIT );
+    TRACE_EXIT_POINT;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteDayRangeL
+// CCalenDeleteUi::DeleteDayRangeL
 // Deletes all entries in a given range.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DeleteDayRangeL( const QDateTime& aStart,
-                                                      const QDateTime& aEnd )
+void CCalenDeleteUi::DeleteDayRangeL( const TTime& aStart,
+                                                      const TTime& aEnd )
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DELETEDAYRANGEL_ENTRY );
-    
+    TRACE_ENTRY_POINT;
+
     iStartTime = aStart;
     iEndTime = aEnd;
-    
-    iIsDeleting = ETrue;
+
+    TCalTime start, end;
+    start.SetTimeLocalL( iStartTime );
+    end.SetTimeLocalL( iEndTime );
+
+    if( iDelAllRange )
+        {
+        delete iDelAllRange;
+        iDelAllRange = NULL;
+        }
     
-    //AgendaUtil& agendaInterface = iController.agendaInterface();
-    // Connect to the signal that gets generated when deletion is completed
-    connect(iController.agendaInterface(), SIGNAL(entriesDeleted(int)), this,
-            SLOT(doCompleted(int)));
-    AgendaUtil::FilterFlags filter =
-    	        AgendaUtil::FilterFlags(AgendaUtil::IncludeAnniversaries
-    	                | AgendaUtil::IncludeAppointments
-    	                | AgendaUtil::IncludeEvents
-    	                | AgendaUtil::IncludeReminders
-    	                | AgendaUtil::IncludeIncompletedTodos
-    	                | AgendaUtil::IncludeCompletedTodos
-    	                | AgendaUtil::IncludeAnniversaries);
-    // 1: First pass, delete all entries.
-    iController.agendaInterface()->deleteEntries(iStartTime, iEndTime, filter);
+    iDelAllRange = new(ELeave) CalCommon::TCalTimeRange( start, end );
+    iDeleteColIds.Reset();
+
+    iIsDeleting = ETrue;   
 
-    OstTraceFunctionExit0( CALENDELETEUI_DELETEDAYRANGEL_EXIT );
+    iController.GetActiveCollectionidsL(iDeleteColIds);
+    
+    //remember the calenders, delete entries in each calendar one by one by calling DeleteL(...) after completed()
+    iNumberOfCalendars = iDeleteColIds.Count();
+    iToShowDeleteNote = 0;
+    iGlobalData->EntryViewL(iDeleteColIds[iToShowDeleteNote])->DeleteL( *iDelAllRange, CalCommon::EIncludeAll, *this );
+        
+    TRACE_EXIT_POINT;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::DoCompletedL
+// CCalenDeleteUi::Completed
+// Completed callback
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenDeleteUi::Completed( TInt aFirstPassError )
+    {
+    TRACE_ENTRY_POINT;
+
+    PIM_TRAPD_HANDLE( DoCompletedL( aFirstPassError ) );
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenDeleteUi::DoCompletedL
 // Handles delete callback
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenDeleteUi::doCompleted( int aFirstPassError )
+void CCalenDeleteUi::DoCompletedL( TInt aFirstPassError )
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DOCOMPLETED_ENTRY );
-
-    if( aFirstPassError == KErrNone )
+    TRACE_ENTRY_POINT;
+    iToShowDeleteNote++;
+    if(iNumberOfCalendars == iToShowDeleteNote)
         {
-        // 2: Second pass, delete notes that end 00:00 of next day of iEndTime
-        // We didn't delete them in first pass
-        QDateTime nextMidnight = CalenDateUtils::beginningOfDay( iEndTime.addDays(1) );
-        nextMidnight = ( nextMidnight < AgendaUtil::maxTime()? nextMidnight : AgendaUtil::maxTime() );
-        PIM_TRAPD_HANDLE( deleteEntriesEndingAtMidnight( nextMidnight ) );
+	    if( aFirstPassError == KErrNone )
+	        {
+	        // 2: Second pass, delete notes that end 00:00 of next day of iEndTime
+	        // We didn't delete them in first pass
+	        TTime nextMidnight = CalenDateUtils::BeginningOfDay( iEndTime + TTimeIntervalDays( 1 ) );
+	        nextMidnight = Min( nextMidnight, TCalTime::MaxTime() );
+	        PIM_TRAPD_HANDLE( DeleteEntriesEndingAtMidnightL( nextMidnight ) );
+	        }
+	        
+		// 3. End deleting, close wait dialog, and show confirmation or error note
+		iIsDeleting = EFalse;
+		iToShowDeleteNote = 0;
+		// dismiss the waitdialog
+		if(iWaitDialog)
+			{
+			TRAP_IGNORE(iWaitDialog->ProcessFinishedL());
+			}
+
+		if( aFirstPassError == KErrNone )
+			{
+			// Show confirmation note
+//			HBufC* buf = StringLoader::LoadLC( iConfirmationNoteId, iEikEnv );
+//			CAknConfirmationNote* dialog = new( ELeave ) CAknConfirmationNote();
+//			dialog->ExecuteLD(*buf);
+//			CleanupStack::PopAndDestroy( buf );
+			}
+		else
+			{
+			// Show error note
+			if(iEikEnv)
+			   {
+			   iEikEnv->ResolveError( aFirstPassError );
+			   }
+			}
+		iDeleteColIds.Reset();
+		delete iDelAllRange;
+		iDelAllRange = NULL;
+		
+	    iController.BroadcastNotification( ECalenNotifyMultipleEntriesDeleted );
+        }
+    else
+        {
+        //delete entries in next calendar...
+        iGlobalData->EntryViewL(iDeleteColIds[iToShowDeleteNote])->DeleteL( *iDelAllRange, CalCommon::EIncludeAll, *this );
         }
 
-    // 3. End deleting, close wait dialog, and show confirmation or error note
-    iIsDeleting = EFalse;
-    
-    iController.BroadcastNotification( ECalenNotifyMultipleEntriesDeleted );
-
-    OstTraceFunctionExit0( CALENDELETEUI_DOCOMPLETED_EXIT );
+    TRACE_EXIT_POINT;
     }
 
 // ----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteEntriesEndingAtMidnightL
+// CCalenDeleteUi::NotifyProgress
+// Delete progress notification
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TBool CCalenDeleteUi::NotifyProgress()
+    {
+    TRACE_ENTRY_POINT;
+    // Tell framework that we are not intrested in Progress notifications.
+    TRACE_EXIT_POINT;
+    return EFalse;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenDeleteUi::Progress
+// Delete progress notification
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenDeleteUi::Progress( TInt /*aPercentageCompleted*/ )
+    {
+    TRACE_ENTRY_POINT;
+    // do nothing, we are not intrested in Progress notifications
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenDeleteUi::DeleteEntriesEndingAtMidnightL
 // Deletes entries ending at midnight on the given day
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenDeleteUi::deleteEntriesEndingAtMidnight( QDateTime aMidnight )
+void CCalenDeleteUi::DeleteEntriesEndingAtMidnightL( TTime aMidnight )
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRIESENDINGATMIDNIGHT_ENTRY );
+    TRACE_ENTRY_POINT;
 
-    QDateTime start, end;
-    QTime startTime(aMidnight.time());
-    startTime.setHMS(startTime.hour(), startTime.minute() - 1,
-                    startTime.second(), startTime.msec());
-    start.setDate(aMidnight.date());
-    start.setTime(startTime);
+    TCalTime start, end;
+    start.SetTimeLocalL( aMidnight - TTimeIntervalMinutes(1) );
+    end.SetTimeLocalL( aMidnight );
+    CalCommon::TCalTimeRange midnightRange( start, end );
+    
+    RArray<TInt> colIdArray;
+    iController.GetActiveCollectionidsL(colIdArray);
     
-    end = aMidnight;
+    // 1: Find instances falling on midnight moment
+    RPointerArray< CCalInstance > instances;
+    CleanupResetAndDestroyPushL( instances );
+    iGlobalData->InstanceViewL(colIdArray)->FindInstanceL( instances,
+                                                 CalCommon::EIncludeAll, 
+                                                 midnightRange );
     
-    QList<AgendaEntry> instances = iController.Services().agendaInterface()->fetchEntriesInRange( start, end );
+    colIdArray.Reset();
 
     // 2. loop through them and delete those entries that end at midnight
-    for( int i=0; i < instances.count(); ++i )
+    for( TInt i=0; i < instances.Count(); ++i )
         {
-        AgendaEntry entry = instances[i];
-
+        CCalInstance* item = instances[i];
+        RArray<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::endsAtStartOfDay( entry, aMidnight ) )
+        if( CalenAgendaUtils::EndsAtStartOfDayL( item, aMidnight ) )
             {
             // Second, check that _entry's_ endtime is exactly the midnight
             // This prevents us from destroying repeating entries, that has one
             // instance falling on given midnight.
-            if( entry.endTime() == aMidnight )
+            if( item->Entry().EndTimeL().TimeLocalL() == aMidnight )
                 {
-                iController.Services().agendaInterface()->deleteRepeatedEntry(entry, AgendaUtil::ThisAndAll);
+                iGlobalData->InstanceViewL(colIdArray)->DeleteL( item, CalCommon::EThisOnly );
+                // Ownership was transferred to DeleteL.
+                // Put null to array to prevent double-deletion
+                instances[i] = NULL;                
                 }
             }
+        colIdArray.Reset();
         }
+    CleanupStack::PopAndDestroy( &instances );
 
-    OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRIESENDINGATMIDNIGHT_EXIT );
+    TRACE_EXIT_POINT;
     }
 
 // -----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteSingleInstanceL
+// CCalenDeleteUi::DeleteSingleInstanceL
 // Delete the given instance. Ask the user whether to delete the series or the instance.
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DeleteSingleInstanceL( AgendaEntry& aInstance )
+TBool CCalenDeleteUi::DeleteSingleInstanceL( CCalInstance* aInstance )
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DELETESINGLEINSTANCEL_ENTRY );
-    
-    DoDeleteSingleInstanceL( aInstance, EFalse, AgendaUtil::ThisAndAll );
-    
-    OstTraceFunctionExit0( CALENDELETEUI_DELETESINGLEINSTANCEL_EXIT );
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    return DoDeleteSingleInstanceL( aInstance, EFalse, CalCommon::EThisAndAll );
     }
 
 // -----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteSingleInstanceL
+// CCalenDeleteUi::DeleteSingleInstanceL
 // Delete the given instance. Delete the entry range given by aRepeatType.
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DeleteSingleInstanceL( AgendaEntry& aInstance, 
-                                AgendaUtil::RecurrenceRange aRepeatType )
+TBool CCalenDeleteUi::DeleteSingleInstanceL( CCalInstance* aInstance, 
+                                                            CalCommon::TRecurrenceRange aRepeatType )
     {
-    OstTraceFunctionEntry0( DUP1_CALENDELETEUI_DELETESINGLEINSTANCEL_ENTRY );
-    
-    DoDeleteSingleInstanceL( aInstance, ETrue, aRepeatType );
-    
-    OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETESINGLEINSTANCEL_EXIT );
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    return DoDeleteSingleInstanceL( aInstance, ETrue, aRepeatType );
     }
 
 // -----------------------------------------------------------------------------
-// CalenDeleteUi::DoDeleteSingleInstanceL
+// CCalenDeleteUi::DoDeleteSingleInstanceL
 // Performs the deletion of the instance. If aHasRepeatType is EFalse, the user
 // is prompted to delete either the instance or the entire series. In this case,
 // aRepeatType is ignored. If aHasRepeatType is ETrue, aRepeatType determines
@@ -880,54 +841,241 @@
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DoDeleteSingleInstanceL(
-									AgendaEntry& aInstance,
-									bool aHasRepeatType,
-									AgendaUtil::RecurrenceRange aRepeatType )
-{
-    OstTraceFunctionEntry0( CALENDELETEUI_DODELETESINGLEINSTANCEL_ENTRY );
+TBool CCalenDeleteUi::DoDeleteSingleInstanceL( CCalInstance* aInstance,
+                                                           TBool aHasRepeatType,
+                                                           CalCommon::TRecurrenceRange aRepeatType )
+    {
+    TRACE_ENTRY_POINT;
+
+    CCalEntry& entry = aInstance->Entry();
+    const CCalEntry::TType entryType = entry.EntryTypeL(); 
+    RArray<TInt> colIdArray;
+    colIdArray.AppendL(aInstance->InstanceIdL().iCollectionId);
     
-	bool repeating = aInstance.isRepeating();
+
+    TCalRRule rrule;
+
+    TBool repeating = entry.GetRRuleL( rrule );
 
-	if( !repeating ) {
-		// Even though there is no RRule, the entry might
-		// have a list of rdates.
-		QList<QDate> rDates = aInstance.rDates();
-		repeating = ( rDates.count() > 0 );
-	}
-	QDateTime recId = aInstance.recurrenceId().toUTC();
-	const bool child = recId.isNull();
+    if( !repeating )
+        {
+        // Even though there is no RRule, the entry might
+        // have a list of rdates.
+        RArray< TCalTime > rDateArray;
+        CleanupClosePushL( rDateArray );
+        entry.GetRDatesL( rDateArray );
+        repeating = ( rDateArray.Count() > 0 );
+        CleanupStack::PopAndDestroy(); // rDateArray
+        }
+
+    const TBool child = entry.RecurrenceIdL().TimeUtcL() != Time::NullTTime();
+
+    if( !aHasRepeatType )
+        {
+        aRepeatType = CalCommon::EThisAndAll;
+        }
+
+    TBool doDelete( ETrue );
 
-	if( !aHasRepeatType ) {
-		aRepeatType = AgendaUtil::ThisAndAll;
-	}
-	// For later reference in handleDeletion()
-	mRecurrenceRange = aRepeatType;
+    if( !aHasRepeatType && ( child || repeating ) && ( entryType != CCalEntry::EAnniv ) )
+        {
+        doDelete = CalenActionUiUtils::ShowRepeatTypeQueryL( aRepeatType,
+                                                           CalenActionUiUtils::EDelete );
+        }
+    else
+        {
+        doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL( 
+                                                                   entryType == CCalEntry::ETodo ?
+                                                                   CalenActionUiUtils::EDeleteToDo :
+                                                                   CalenActionUiUtils::EDeleteEntry );
+        }
+        
+    if( doDelete )
+        {
+        //Before deleteing the entry reset the attachment model
+        if(iController.Services().GetAttachmentData()->NumberOfItems())
+            {
+            iController.Services().GetAttachmentData()->Reset();
+            }
+        
+        if( !TryDeleteWithMrUtilsL( aInstance, aRepeatType ) )
+            {
+            if( !child || aRepeatType == CalCommon::EThisOnly )
+                {
+                iGlobalData->InstanceViewL(colIdArray)->DeleteL( aInstance, aRepeatType );
+                }
+            else if( aRepeatType == CalCommon::EThisAndAll )
+                {
+                // Unfortunately we can't pass the existing child instance through to the
+                // InstanceView DeleteL function because even if we pass in EThisAndAll, it
+                // only ever deletes the exception. We'll have to fetch the parent then
+                // delete it via the entry view.
+                RPointerArray<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 );
+                }
+            }
+        }
 
-	if( !aHasRepeatType && ( child || repeating ) && 
-			( aInstance.type() != AgendaEntry::TypeAnniversary ) ) {
-		showRepeatingEntryDeleteQuery();
-	}
-	else
-	{
-		showDeleteQuery(aInstance.type() == AgendaEntry::TypeTodo ?
-														EDeleteToDo :
-														EDeleteEntry );
-	}
-	OstTraceFunctionExit0( CALENDELETEUI_DODELETESINGLEINSTANCEL_EXIT );
-}
-
+    colIdArray.Reset();
+    TRACE_EXIT_POINT;
+    return doDelete;
+    }
 
 // -----------------------------------------------------------------------------
-// CalenDeleteUi::DialogDismissedL
+// CCalenDeleteUi::DeleteEntryL
+// Deletes an entry from the database
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenDeleteUi::DeleteEntryL( CCalEntryView* aEntryView, CCalEntry* aEntry )
+    {
+    TRACE_ENTRY_POINT;
+    const CCalEntry::TType entryType = aEntry->EntryTypeL();
+
+    TBool doDelete = CalenActionUiUtils::ShowDeleteConfirmationQueryL( 
+                                                                    entryType == CCalEntry::ETodo ?
+                                                                    CalenActionUiUtils::EDeleteToDo :
+                                                                    CalenActionUiUtils::EDeleteEntry );
+    if( doDelete )
+        {
+        //Before deleteing the attachment, reset the attachment model
+        if(iController.Services().GetAttachmentData()->NumberOfItems())
+            {
+            iController.Services().GetAttachmentData()->Reset();
+            }
+        aEntryView->DeleteL( *aEntry );
+
+        if( aEntry )
+            {
+            delete aEntry;
+            aEntry = NULL;
+            }
+        }
+
+    TRACE_EXIT_POINT;
+    return doDelete;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenDeleteUi::TryDeleteWithMrUtilsL
+// Attempt to delete the instance using the Meeting Request utilities,
+// if MR viewers is enabled.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CCalenDeleteUi::TryDeleteWithMrUtilsL( CCalInstance* aInstance, 
+                                                              CalCommon::TRecurrenceRange aRepeatType )
+    {
+    TRACE_ENTRY_POINT;
+    
+    TBool doDelete = ETrue;
+
+	if( iGlobalData->InterimUtilsL().MRViewersEnabledL() && 
+        iGlobalData->InterimUtilsL().IsMeetingRequestL(aInstance->Entry()))
+
+        {
+        CMRMailboxUtils::TMailboxInfo info;
+        if( iGlobalData->AttemptToRetrieveDefaultMailboxL( info ) )
+            {
+            if(aRepeatType == CalCommon::EThisAndAll )
+                {
+                iGlobalData->MeetingRequestUtilsL().DeleteWithUiL( aInstance->Entry(),
+                                                                                      info.iEntryId );
+                if( aInstance )
+                    {
+                    delete aInstance;
+                    aInstance = NULL;
+                    }
+                }
+            else if( aRepeatType == CalCommon::EThisOnly )
+                {
+                iGlobalData->MeetingRequestUtilsL().DeleteWithUiL( aInstance, info.iEntryId );
+                }
+            else
+                {
+                User::Leave( KErrNotSupported );
+                }
+            }
+        else
+            {
+            doDelete = EFalse;
+            }
+        }
+    else
+        {
+        doDelete = EFalse;
+        }
+
+    TRACE_EXIT_POINT;
+    return doDelete;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenDeleteUi::ShowMultipleEntriesDeleteQueryL
+// For displaying multiple entries deletion confirmation query
+// -----------------------------------------------------------------------------
+//
+TInt CCalenDeleteUi::ShowMultipleEntriesDeleteQueryL(TInt aCount)
+	{
+    TRACE_ENTRY_POINT;
+
+    CAknQueryDialog *dialog = CAknQueryDialog::NewL( );
+    CleanupStack::PushL( dialog );
+    TInt resID;
+    HBufC* prompt;
+    if( aCount > 1 )
+        {
+        resID = R_CALEN_QTN_TODO_QUEST_DELETE_MARKED_NOTES;
+        prompt = StringLoader::LoadLC( resID, aCount );
+        }
+    else if( aCount ==  1 )
+        {
+        resID = R_CALEN_QTN_TODO_QUEST_DELETE_MARKED_NOTE;
+        prompt = StringLoader::LoadLC( resID );
+        }
+    else
+        {
+        CleanupStack::PopAndDestroy( dialog );
+        TRACE_EXIT_POINT;
+        return 0;   //return 0 for other invalid aCount value ( < 0 )
+        }
+    dialog->SetPromptL( *prompt );
+    CleanupStack::PopAndDestroy( prompt );
+
+    CleanupStack::Pop( dialog );
+
+    TRACE_EXIT_POINT;
+    return dialog->ExecuteLD( R_CALEN_ERASEQUERY_NOTE );
+
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenDeleteUi::DialogDismissedL
 // From MProgressDialogCallback
 // Callback method
 // called when a dialog is dismissed.
 // -----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DialogDismissedL( const TInt /*aButtonId*/ )
+void CCalenDeleteUi::DialogDismissedL( const TInt /*aButtonId*/ )
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DIALOGDISMISSEDL_ENTRY );
+    TRACE_ENTRY_POINT;
+    // dismiss the wait dialog
+    if(iWaitDialog)
+        {
+        iWaitDialog->ProcessFinishedL();
+        }
     
     // no more entries to delete
     iMoreEntriesToDelete = EFalse;
@@ -935,49 +1083,136 @@
     
     // issue notification cancel delete
     iController.BroadcastNotification(ECalenNotifyCancelDelete);
-    
-    OstTraceFunctionExit0( CALENDELETEUI_DIALOGDISMISSEDL_EXIT );
+    TRACE_EXIT_POINT;
     }
 
 // -----------------------------------------------------------------------------
-// CalenDeleteUi::DeleteEntryL
+// CCalenDeleteUi::DeleteEntryL
 // Delete entry using entry local uid
 // -----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DeleteEntryL(ulong& aEntryLocalUid)
+void CCalenDeleteUi::DeleteEntryL(TCalLocalUid& aEntryLocalUid, TInt aColId)
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRYL_ENTRY );
+    TRACE_ENTRY_POINT;
     
-    iController.Services().agendaInterface()->deleteEntry(aEntryLocalUid);
+    // fetch the entry
+    CCalEntry* entry = iGlobalData->EntryViewL(aColId)->FetchL(aEntryLocalUid);
+    if( entry )
+        {
+        CleanupStack::PushL( entry );
+        iGlobalData->EntryViewL(aColId)->DeleteL( *entry );
+        CleanupStack::Pop( entry );
+        delete entry;
+        entry = NULL;
+        }   
     
-    OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRYL_EXIT );
+    TRACE_EXIT_POINT;
     }
 
 // -----------------------------------------------------------------------------
-// CalenDeleteUi::DisplayWaitDialogL
+// CCalenDeleteUi::DisplayWaitDialogL
 // Display wait dialog
 // -----------------------------------------------------------------------------
 //
-void CalenDeleteUi::DisplayWaitDialogL()
+void CCalenDeleteUi::DisplayWaitDialogL()
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_DISPLAYWAITDIALOGL_ENTRY );
+    TRACE_ENTRY_POINT;
     
-    OstTraceFunctionExit0( CALENDELETEUI_DISPLAYWAITDIALOGL_EXIT );
+    delete iWaitDialog;
+    iWaitDialog = NULL;
+    iWaitDialog = new( ELeave )CAknWaitDialog( REINTERPRET_CAST( CEikDialog**, &iWaitDialog ), ETrue );
+    iWaitDialog->ExecuteLD( R_TODO_VIEW_DELETE_WAIT_NOTE );
+    iWaitDialog->SetCallback(this);
+    
+    TRACE_EXIT_POINT;
     }
 
 // -----------------------------------------------------------------------------
-// CalenDeleteUi::MarkedEntriesDeletedL
+// CCalenDeleteUi::MarkedEntriesDeletedL
 // Dismiss wait dialog and show information note
 // -----------------------------------------------------------------------------
 //
-void CalenDeleteUi::MarkedEntriesDeletedL()
+void CCalenDeleteUi::MarkedEntriesDeletedL()
     {
-    OstTraceFunctionEntry0( CALENDELETEUI_MARKEDENTRIESDELETEDL_ENTRY );
+    TRACE_ENTRY_POINT;
     
+    // dismiss the waitdialog
+    if(iWaitDialog)
+        {
+        iWaitDialog->ProcessFinishedL();
+        }
+    
+    // Show confirmation note
+    //HBufC* buf = StringLoader::LoadLC( R_QTN_CALE_CONF_ALL_NOTES_DELETED, iEikEnv );
+    //CAknConfirmationNote* dialog = new( ELeave ) CAknConfirmationNote();
+    //dialog->ExecuteLD(*buf);
+    //CleanupStack::PopAndDestroy( buf );
+
     // notify marked entries deleted
     iController.BroadcastNotification( ECalenNotifyMarkedEntryDeleted );
     
-    OstTraceFunctionExit0( CALENDELETEUI_MARKEDENTRIESDELETEDL_EXIT );
+    TRACE_EXIT_POINT;
     }
 
+// -----------------------------------------------------------------------------
+// CCalenDeleteUi::HandleDeleteAllEntriesL
+// Handles launching of the delete all entries list query
+// -----------------------------------------------------------------------------
+//
+void CCalenDeleteUi::HandleDeleteAllEntriesL()
+    {
+    TRACE_ENTRY_POINT;
+    RPointerArray<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