/*
* 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".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Handles deletion
*
*/

// System includes
#include <QString>
#include <QtGui>
#include <hbdatetimepicker.h>
#include <hbdialog.h>
#include <hbmessagebox.h>
#include <hbaction.h>
#include <hblabel.h>
#include <hbradiobuttonlist.h>
#include <centralrepository.h>
#include <agendaentry.h>

// User includes
#include "calendarui_debug.h"
#include "calendeleteui.h"
#include "calencontext.h"
#include "calencontroller.h"
#include "CleanupResetAndDestroy.h"
#include "caleninstanceid.h"
#include "calenactionuiutils.h"
#include "CalendarPrivateCRKeys.h"  // includes CalendarInternalCRKeys.h
#include "calendateutils.h"
#include "calenagendautils.h"


// Local constants
const TInt KEntriesToDelete = 1;

// ----------------------------------------------------------------------------
// CalenDeleteUi::NewL
// Two phased constructor
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
CalenDeleteUi* CalenDeleteUi::NewL( CCalenController& aController )
    {
    TRACE_ENTRY_POINT;

    CalenDeleteUi* self = new( ELeave ) CalenDeleteUi( aController, NULL );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;
    return self;
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::CalenDeleteUi
// ?implementation_description
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
CalenDeleteUi::CalenDeleteUi( CCalenController& aController, QObject *parent )
    :QObject(parent), iController( aController )
    {
    TRACE_ENTRY_POINT;
    iIsDeleting = false;
    TRACE_EXIT_POINT;
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::~CalenDeleteUi
// Destructor
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
CalenDeleteUi::~CalenDeleteUi()
    {
    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::ConstructL
// Second phase of construction
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::ConstructL()
    {
    TRACE_ENTRY_POINT;
    iController.RegisterForNotificationsL( this, ECalenNotifyCancelDelete );
    iMoreEntriesToDelete = EFalse;
    iDisplayQuery = EFalse;
    iEntriesToDelete = KEntriesToDelete;
    TRACE_EXIT_POINT;
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::HandleNotification
// Handles notifications.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::HandleNotification(const TCalenNotification aNotification )
    {
    TRACE_ENTRY_POINT;

    if( aNotification == ECalenNotifyCancelDelete)
        {
        if(iMutlipleContextIdsCount)
            {
            // get the context
            MCalenContext& context = iController.context();
            // reset the multiple contexts
            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:
        	mDeleteCommand = 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 ECalenDeleteAllEntries:
        	mDeleteCommand = 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;

	if( iController.context().instanceId().mEntryLocalUid )
	{
		AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL(
									iController.context().instanceId(),
									iController.Services().agendaInterface() );
		if( !instance.isNull() )
		{
			DeleteSingleInstanceL( instance, aRepeatType );
		}
	}
	TRACE_EXIT_POINT;
}

// ----------------------------------------------------------------------------
// CalenDeleteUi::DeleteEntryWithoutQueryL()
// Deletes the current entry
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
TBool CalenDeleteUi::DeleteEntryWithoutQueryL()
    {
    TRACE_ENTRY_POINT;
	bool continueCommand(EFalse);
    
	// get the context
	MCalenContext& context = iController.context();
	
	// get the multliple context ids count
	iMutlipleContextIdsCount = context.mutlipleContextIdsCount();
	
	ASSERT( iMutlipleContextIdsCount );

	    if(!iMoreEntriesToDelete)
		    {
		    //iDisplayQuery = ShowMultipleEntriesDeleteQueryL(iMutlipleContextIdsCount);
		    }
		
		if(iDisplayQuery)
			{
			if(!iMoreEntriesToDelete)	
			    {
			    DisplayWaitDialogL();
			    }
			// get the multiple context instance ids
			QList<TCalenInstanceId>& multipleContextIds = context.getMutlipleContextIds();
			
			if(iMutlipleContextIdsCount <= iEntriesToDelete )
			    {
			    iMoreEntriesToDelete = EFalse; 
			    iEntriesToDelete = iMutlipleContextIdsCount;
			    }
			else
			    {
			    iMoreEntriesToDelete = ETrue;
	            // set the continue command flag if more entries are there to delete
			    continueCommand = ETrue;
			    }
			    
			TInt index(0);
			while(index<iEntriesToDelete)
			    {
			    // get the local uid of the entry through multiple context list
			    ulong entryLocalUid = multipleContextIds[0].mEntryLocalUid;
			    if(entryLocalUid)
			        {
			        DeleteEntryL(entryLocalUid);
			        }
			    // remove mutliple context based on the instanceid
			    context.removeMultipleContextId(multipleContextIds[0]);
			    index++;
			   }

			if(!iMoreEntriesToDelete)
			    {
			    MarkedEntriesDeletedL();    
			    }
			}
        else
            {
            context.resetMultipleContextIds();
            // notify delete failed
            iController.BroadcastNotification(ECalenNotifyDeleteFailed);    
            }
	
    TRACE_EXIT_POINT;
    return continueCommand;
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::DeleteCurrentEntryL
// Deletes the current entry
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::DeleteCurrentEntryL()
{
	TRACE_ENTRY_POINT;

	// 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()) {
			if(!entry.isNull()) {
				showDeleteQuery(entry.type() == AgendaEntry::TypeTodo ?
															EDeleteToDo :
															EDeleteEntry );
			}
		}
		else {
			if (entry.isRepeating() || !entry.recurrenceId().isNull()) {
				// Show a confirmation note whether the user
				// wants to delete the single instance or all of them
				showRepeatingEntryDeleteQuery();
			} else {
				// If the entry is not a repeating entry,
				// delete it directly
				// Save the entry for later reference in the slot
				showDeleteQuery(entry.type() == AgendaEntry::TypeTodo ?
															EDeleteToDo :
															EDeleteEntry );
			}
		}
	}
	TRACE_EXIT_POINT;
}

// ----------------------------------------------------------------------------
// CalenDeleteUi::DeleteAllEntriesL
// Deletes all entries
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::DeleteAllEntriesL()
    {
    ASSERT( !iIsDeleting );

    showDeleteQuery(EDeleteAll );
	}

// ----------------------------------------------------------------------------
// CalenDeleteUi::DeleteEntriesBeforeDateL
// Deletes all entries before a set date.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::DeleteEntriesBeforeDateL()
    {
    TRACE_ENTRY_POINT;
    ASSERT( !iIsDeleting );
    
    // launch the datepicker
    dateQuery();
    TRACE_EXIT_POINT;
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::dateQuery
// Launches the popup for the date selection
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::dateQuery()
	{
	// 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);  
	
	popUp->addAction(new HbAction(hbTrId("txt_calendar_button_dialog_delete")));
	popUp->addAction(new HbAction(hbTrId("txt_common_button_cancel"),popUp));
	// Show the popup
	popUp->open(this, SLOT(handleDateQuery(HbAction*)));
	}

// ----------------------------------------------------------------------------
// CalenDeleteUi::handleDateQuery
// Handles the selection for the date query
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::handleDateQuery(HbAction* action)
{
	if(action->text() == hbTrId("txt_calendar_button_dialog_delete")) {
		getSelectedDateAndDelete();
	}else {
		handleDeleteCancel();
	}
}
// ----------------------------------------------------------------------------
// CalenDeleteUi::showRepeatingEntryDeleteQuery
// Launches the popup for deleting the repeating entry
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::showRepeatingEntryDeleteQuery()
{
    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_calendar_button_softkey1_cancel"));
    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();
}

// ----------------------------------------------------------------------------
// CalenDeleteUi::handleDeleteCancel
// Handles the cancel action
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::handleDeleteCancel()
{
	iController.BroadcastNotification(ECalenNotifyDeleteFailed);
}

// ----------------------------------------------------------------------------
// CalenDeleteUi::getSelectedDateAndDelete
// Deletes the entries before the selected date
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::getSelectedDateAndDelete()
{
	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 );
			iController.BroadcastNotification(ECalenNotifyEntryDeleted);
		}else {
			iController.BroadcastNotification(ECalenNotifyDeleteFailed);
		}
	}
}

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;
        }
    }
}

// ----------------------------------------------------------------------------
// 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)
    {
    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:
            {
            // TODO: Add the text id
            text.append("Delete entry?");
            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;
            }
        default:
            break;
        }
    
    popup->setText(text);
    	
    QList<QAction*> list = popup->actions();
    for(int i=0; i < list.count(); i++)
        {
        popup->removeAction(list[i]);
        }
    popup->addAction(new HbAction(hbTrId("txt_calendar_button_delete"), popup));
    popup->addAction(new HbAction(
    		hbTrId("txt_calendar_button_cancel"), popup));
    popup->open(this, SLOT(handleDeletion(HbAction*)));
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::handleDeletion
// Deletes the entries based on the user selection
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::handleDeletion(HbAction* action)
{
	TCalenNotification notification = ECalenNotifyDeleteFailed;
	
	if(action->text() == hbTrId("txt_calendar_button_delete")) {
		
		switch (mDeleteCommand) {
			
			case ECalenDeleteCurrentEntry:
			{
				// Get the entry
				AgendaEntry entry = 
						iController.Services().agendaInterface()->fetchById(
							iController.context().instanceId().mEntryLocalUid);
				// Delete the entry if the delete button is been pressed
				iController.Services().agendaInterface()->deleteEntry(entry.id());
				notification = ECalenNotifyEntryDeleted;
			}
				break;
			
			case ECalenDeleteSeries:
			case ECalenDeleteCurrentOccurrence:
			{
				AgendaEntry instance = 
						CalenActionUiUtils::findPossibleInstanceL(
								iController.context().instanceId(),
								iController.Services().agendaInterface() );
				QDateTime recId = instance.recurrenceId().toUTC();
				const bool child = recId.isNull();

				if( !child || mRecurrenceRange == AgendaUtil::ThisOnly 
						|| mRecurrenceRange == AgendaUtil::ThisAndAll) {
					iController.Services().agendaInterface()->deleteRepeatedEntry( 
							instance, mRecurrenceRange );
				}
				notification = ECalenNotifyEntryDeleted;
			}
				break;
			
			case ECalenDeleteAllEntries:
			{
				HandleDeleteMultipleEventsL( AgendaUtil::minTime(), 
											AgendaUtil::maxTime(),1 );
				notification = ECalenNotifyEntryDeleted;
			}
				break;
			
			default:
				break;
				
		}
	}
	// If the user presses cancel button the notification will be
	// ECalenNotifyDeleteFailed as default.
	// Notify the status
	iController.BroadcastNotification(notification);
}

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 CalenDeleteUi::HandleDeleteMultipleEventsL( const QDateTime& aFirstDay,
                                                 const QDateTime& aLastDay,
                                                 int aConfNoteId )
    {
    TRACE_ENTRY_POINT;

    
    ASSERT( !iIsDeleting );
    iConfirmationNoteId = aConfNoteId;
    
    DeleteDayRangeL( aFirstDay, aLastDay );

    TRACE_EXIT_POINT;
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::DeleteDayRangeL
// Deletes all entries in a given range.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::DeleteDayRangeL( const QDateTime& aStart,
                                                      const QDateTime& aEnd )
    {
    TRACE_ENTRY_POINT;

    iStartTime = aStart;
    iEndTime = aEnd;
    
    iIsDeleting = ETrue;
    
    //AgendaUtil& agendaInterface = iController.agendaInterface();
    // Connect to the signal that gets generated when deletion is completed
    connect(iController.agendaInterface(), SIGNAL(entriesDeleted(int)), this,
            SLOT(doCompleted(int)));
    AgendaUtil::FilterFlags filter =
    	        AgendaUtil::FilterFlags(AgendaUtil::IncludeAnniversaries
    	                | AgendaUtil::IncludeAppointments
    	                | AgendaUtil::IncludeEvents
    	                | AgendaUtil::IncludeReminders
    	                | AgendaUtil::IncludeIncompletedTodos);
    // 1: First pass, delete all entries.
    iController.agendaInterface()->deleteEntries(iStartTime, iEndTime, filter);

    TRACE_EXIT_POINT;
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::DoCompletedL
// Handles delete callback
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::doCompleted( int aFirstPassError )
    {
    TRACE_ENTRY_POINT;

    if( aFirstPassError == KErrNone )
        {
        // 2: Second pass, delete notes that end 00:00 of next day of iEndTime
        // We didn't delete them in first pass
        QDateTime nextMidnight = CalenDateUtils::beginningOfDay( iEndTime.addDays(1) );
        nextMidnight = ( nextMidnight < AgendaUtil::maxTime()? nextMidnight : AgendaUtil::maxTime() );
        PIM_TRAPD_HANDLE( deleteEntriesEndingAtMidnight( nextMidnight ) );
        }

    // 3. End deleting, close wait dialog, and show confirmation or error note
    iIsDeleting = EFalse;
    
    iController.BroadcastNotification( ECalenNotifyMultipleEntriesDeleted );

    TRACE_EXIT_POINT;
    }

// ----------------------------------------------------------------------------
// CalenDeleteUi::DeleteEntriesEndingAtMidnightL
// Deletes entries ending at midnight on the given day
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CalenDeleteUi::deleteEntriesEndingAtMidnight( QDateTime aMidnight )
    {
    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);
    
    end = aMidnight;
    
    QList<AgendaEntry> instances = iController.Services().agendaInterface()->fetchEntriesInRange( start, end );

    // 2. loop through them and delete those entries that end at midnight
    for( int i=0; i < instances.count(); ++i )
        {
        AgendaEntry entry = instances[i];

        // Checking that if entry ends at midnight, is quite clumsy, but here goes:
        // EndsAtStartOfDay takes only CCalInstance, but here we mimic EndsAtStartOfDay
        // for CCalEntry type.

        // First check that if _instance_ ends at midnight, but starts earlier
        if( CalenAgendaUtils::endsAtStartOfDayL( entry, aMidnight ) )
            {
            // Second, check that _entry's_ endtime is exactly the midnight
            // This prevents us from destroying repeating entries, that has one
            // instance falling on given midnight.
            if( entry.endTime() == aMidnight )
                {
                iController.Services().agendaInterface()->deleteRepeatedEntry(entry, AgendaUtil::ThisAndAll);
                }
            }
        }

    TRACE_EXIT_POINT;
    }

// -----------------------------------------------------------------------------
// CalenDeleteUi::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 )
    {
    TRACE_ENTRY_POINT;
    DoDeleteSingleInstanceL( aInstance, EFalse, AgendaUtil::ThisAndAll );
    TRACE_EXIT_POINT;
    }

// -----------------------------------------------------------------------------
// CalenDeleteUi::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 )
    {
    TRACE_ENTRY_POINT;
    DoDeleteSingleInstanceL( aInstance, ETrue, aRepeatType );
    TRACE_EXIT_POINT;
    
    }

// -----------------------------------------------------------------------------
// 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).
// -----------------------------------------------------------------------------
//
void CalenDeleteUi::DoDeleteSingleInstanceL(
									AgendaEntry& aInstance,
									bool aHasRepeatType,
									AgendaUtil::RecurrenceRange aRepeatType )
{
	TRACE_ENTRY_POINT;
	bool repeating = aInstance.isRepeating();

	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( !aHasRepeatType ) {
		aRepeatType = AgendaUtil::ThisAndAll;
	}
	// For later reference in handleDeletion()
	mRecurrenceRange = aRepeatType;

	if( !aHasRepeatType && ( child || repeating ) && 
			( aInstance.type() != AgendaEntry::TypeAnniversary ) ) {
		//doDelete = CalenActionUiUtils::ShowRepeatTypeQueryL( aRepeatType,
		//                                                 CalenActionUiUtils::EDelete );
	}
	else
	{
		showDeleteQuery(aInstance.type() == AgendaEntry::TypeTodo ?
														EDeleteToDo :
														EDeleteEntry );
	}
	TRACE_EXIT_POINT;
}


// -----------------------------------------------------------------------------
// CalenDeleteUi::DialogDismissedL
// From MProgressDialogCallback
// Callback method
// called when a dialog is dismissed.
// -----------------------------------------------------------------------------
//
void CalenDeleteUi::DialogDismissedL( const TInt /*aButtonId*/ )
    {
    TRACE_ENTRY_POINT;
    
    // no more entries to delete
    iMoreEntriesToDelete = EFalse;
    iDisplayQuery = EFalse;
    
    // issue notification cancel delete
    iController.BroadcastNotification(ECalenNotifyCancelDelete);
    TRACE_EXIT_POINT;
    }

// -----------------------------------------------------------------------------
// CalenDeleteUi::DeleteEntryL
// Delete entry using entry local uid
// -----------------------------------------------------------------------------
//
void CalenDeleteUi::DeleteEntryL(ulong& aEntryLocalUid)
    {
    TRACE_ENTRY_POINT;
    
    iController.Services().agendaInterface()->deleteEntry(aEntryLocalUid);
    
    TRACE_EXIT_POINT;
    }

// -----------------------------------------------------------------------------
// CalenDeleteUi::DisplayWaitDialogL
// Display wait dialog
// -----------------------------------------------------------------------------
//
void CalenDeleteUi::DisplayWaitDialogL()
    {
    TRACE_ENTRY_POINT;   
    TRACE_EXIT_POINT;
    }

// -----------------------------------------------------------------------------
// CalenDeleteUi::MarkedEntriesDeletedL
// Dismiss wait dialog and show information note
// -----------------------------------------------------------------------------
//
void CalenDeleteUi::MarkedEntriesDeletedL()
    {
    TRACE_ENTRY_POINT;    
    // notify marked entries deleted
    iController.BroadcastNotification( ECalenNotifyMarkedEntryDeleted );
    
    TRACE_EXIT_POINT;
    }

// End of File