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

equal deleted inserted replaced

-:5de72ea7a065
+:579cc610882e
 	// 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
-		// Check if the entry is a To-Do
+			if (AgendaEntry::TypeTodo == entry.type()) {
-		if (AgendaEntry::TypeTodo == entry.type()) {
+				showDeleteQuery(EDeleteToDo);
-			if(!entry.isNull()) {
+			} else {
-				showDeleteQuery(entry.type() == AgendaEntry::TypeTodo ?
+				// Show the repeat entry delete query for repeating entries except Anniversary
-															EDeleteToDo :
+				// Even though the anniversary is repeating
-															EDeleteEntry );
+				// 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 the entry is not a repeating entry,
+					// delete it directly
+					// Save the entry for later reference in the slot
+					showDeleteQuery(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;
 }
 // ----------------------------------------------------------------------------
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DeleteAllEntriesL()
 {
-ASSERT( !iIsDeleting );
+	if(iIsDeleting) {
+		return;
+	}
 showDeleteQuery(EDeleteAll );
 	}
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DeleteEntriesBeforeDateL()
 {
 TRACE_ENTRY_POINT;
-ASSERT( !iIsDeleting );
+	if(iIsDeleting) {
+		return;
+	}
 // launch the datepicker
 dateQuery();
 TRACE_EXIT_POINT;
 }
 	mDatePicker->setMinimumDate(CalenDateUtils::minTime().date());
 	mDatePicker->setMaximumDate(currentDate);
 	mDatePicker->setDate(currentDate);
 	popUp->setContentWidget(mDatePicker);
+	mDeleteAction = new HbAction(
-	popUp->addAction(new HbAction(hbTrId("txt_calendar_button_dialog_delete")));
+						hbTrId("txt_calendar_button_dialog_delete"), popUp);
-	popUp->addAction(new HbAction(hbTrId("txt_common_button_cancel"),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*)));
 	}
 // ----------------------------------------------------------------------------
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::handleDateQuery(HbAction* action)
 {
-	if(action->text() == hbTrId("txt_calendar_button_dialog_delete")) {
+	if(action == mDeleteAction) {
-		getSelectedDateAndDelete();
+		// 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;
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::showRepeatingEntryDeleteQuery
 // Launches the popup for deleting the repeating entry
 // (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 );
-		}else {
-			iController.BroadcastNotification(ECalenNotifyDeleteFailed);
-		}
-	}
-}
 void CalenDeleteUi::handleRepeatedEntryDelete(int index)
 {
-// Fetch the entry
+	// Fetch the entry
-// Find all possible instances
+	// Find all possible instances
-AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL(
+	AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL(
-iController.context().instanceId(),
+									iController.context().instanceId(),
-iController.Services().agendaInterface());
+									iController.Services().agendaInterface());
-if (!instance.isNull()) {
+	if (!instance.isNull()) {
-connect(iController.Services().agendaInterface(), SIGNAL(entryDeleted(ulong)),
+		connect(iController.Services().agendaInterface(),
-this, SLOT(entryDeleted(ulong)));
+									SIGNAL(entryDeleted(ulong)),
-switch(index) {
+									this, SLOT(entryDeleted(ulong)));
-case 0:
+		switch(index) {
-// User wants to delete only this occurence
+			case 0:
-iController.Services().agendaInterface()->deleteRepeatedEntry(instance, AgendaUtil::ThisOnly);
+				// User wants to delete only this occurence
-break;
+				iController.Services().agendaInterface()->deleteRepeatedEntry(
-case 1:
+									instance, AgendaUtil::ThisOnly);
-// User wants to delete all the occurences
+				break;
-iController.Services().agendaInterface()->deleteRepeatedEntry(instance, AgendaUtil::ThisAndAll);
+			case 1:
-break;
+				// 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
 switch(type)
 {
 case EDeleteEntry:
 {
-// TODO: Add the text id
+text.append(hbTrId("txt_calendar_info_delete_meeting"));
-text.append("Delete entry?");
 break;
 }
 case EDeleteToDo:
 {
 text.append(hbTrId("txt_calendar_info_delete_todo_note"));
 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));
+mDeleteAction = new HbAction(
-popup->addAction(new HbAction(
+						hbTrId("txt_calendar_button_dialog_delete"), popup);
-		hbTrId("txt_calendar_button_cancel"), popup));
+popup->addAction(mDeleteAction);
+mCancelAction = new HbAction(hbTrId("txt_calendar_button_cancel"), popup);
+popup->addAction(mCancelAction);
 popup->open(this, SLOT(handleDeletion(HbAction*)));
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::handleDeletion
 //
 void CalenDeleteUi::handleDeletion(HbAction* action)
 {
 	TCalenNotification notification = ECalenNotifyDeleteFailed;
-	if(action->text() == hbTrId("txt_calendar_button_delete")) {
+	if(action == mDeleteAction) {
 		switch (mDeleteCommand) {
 			case ECalenDeleteCurrentEntry:
 			{
-				// Get the entry
+				// Get the entry id
-				AgendaEntry entry =
+				ulong id = iController.context().instanceId().mEntryLocalUid;
-						iController.Services().agendaInterface()->fetchById(
+				connect(iController.Services().agendaInterface(),
-							iController.context().instanceId().mEntryLocalUid);
+												SIGNAL(entryDeleted(ulong)),
+												this, SLOT(entryDeleted(ulong)));
 				// Delete the entry if the delete button is been pressed
-				iController.Services().agendaInterface()->deleteEntry(entry.id());
+				iController.Services().agendaInterface()->deleteEntry(id);
-				notification = ECalenNotifyEntryDeleted;
 			}
 				break;
 			case ECalenDeleteSeries:
 			case ECalenDeleteCurrentOccurrence:
 			{
 				AgendaEntry instance =
 						CalenActionUiUtils::findPossibleInstanceL(
 								iController.context().instanceId(),
 								iController.Services().agendaInterface() );
-				QDateTime recId = instance.recurrenceId().toUTC();
+				if(!instance.isNull()) {
-				const bool child = recId.isNull();
+					QDateTime recId = instance.recurrenceId().toUTC();
+					const bool child = recId.isNull();
-				if( !child || mRecurrenceRange == AgendaUtil::ThisOnly
+					connect(iController.Services().agendaInterface(),
-						|| mRecurrenceRange == AgendaUtil::ThisAndAll) {
+					        SIGNAL(entryDeleted(ulong)),
-					iController.Services().agendaInterface()->deleteRepeatedEntry(
+					        this, SLOT(entryDeleted(ulong)));
-							instance, mRecurrenceRange );
+					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);
+	// Reset the member variables
+	mDeleteAction = NULL;
+	mCancelAction = NULL;
 }
 void CalenDeleteUi::entryDeleted(ulong id)
 {
 if (iController.context().instanceId().mEntryLocalUid == id) {
 void CalenDeleteUi::HandleDeleteMultipleEventsL( const QDateTime& aFirstDay,
 const QDateTime& aLastDay,
 int aConfNoteId )
 {
 TRACE_ENTRY_POINT;
+	if(iIsDeleting) {
-ASSERT( !iIsDeleting );
+		return;
+	}
 iConfirmationNoteId = aConfNoteId;
 DeleteDayRangeL( aFirstDay, aLastDay );
 TRACE_EXIT_POINT;
 // 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 ) )
+if( CalenAgendaUtils::endsAtStartOfDay( 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 )
 	// For later reference in handleDeletion()
 	mRecurrenceRange = aRepeatType;
 	if( !aHasRepeatType && ( child || repeating ) &&
 			( aInstance.type() != AgendaEntry::TypeAnniversary ) ) {
-		//doDelete = CalenActionUiUtils::ShowRepeatTypeQueryL( aRepeatType,
+		showRepeatingEntryDeleteQuery();
-		//                                                 CalenActionUiUtils::EDelete );
 	}
 	else
 	{
 		showDeleteQuery(aInstance.type() == AgendaEntry::TypeTodo ?
 														EDeleteToDo :

changeset 50	579cc610882e
parent 37	360d55486d7f
child 58	ef813d54df51