FCL/sf/app/organizer: comparison agendainterface/agendautil/src/agendautil

equal deleted inserted replaced

-:360d55486d7f
+:5de72ea7a065
 // System includes
 #include <hbextendedlocale.h>
 #include <calsession.h>
 #include <calinstance.h>
 #include <CalenImporter>
+#include <CalenInterimUtils2>
 #include <calentry.h>
 #include <calrrule.h>
 #include <e32math.h>
 #include <caluser.h>
 #include <caldataexchange.h>
 // User includes
 #include "agendautil_p.h"
 #include "agendaentry.h"
 #include "agendaentry_p.h"
+#include "CleanupResetAndDestroy.h"
 // Constants
 //recognition string for ical
 _LIT8(KVersionICal,		"VERSION:2.0");
 //recognition string for vcal
 }
 void AgendaUtilPrivate::Completed(TInt aError)
 {
 	iError = aError;
+	static bool isInstanceViewDeleted = false;
+	static bool isEntryViewDeleted = false;
 	if (mIsDeleting) {
 		// If deletion was in progress, then it is completed now
 		// emit the signal to the clients.
 		mIsDeleting = false;
 		emit q->entriesDeleted(iError);
 	}
 	if (KErrNone != iError) {
 		// Something has gone wrong, return
-		if (iCalEntryView) {
+		if (iCalEntryView && !isEntryViewDeleted) {
+		isEntryViewDeleted = true;
 		delete iCalEntryView;
 		iCalEntryView = NULL;
 		}
-		if (iCalInstanceView) {
+		if (iCalInstanceView && !isInstanceViewDeleted) {
+		isInstanceViewDeleted = true;
 		delete iCalInstanceView;
 		iCalInstanceView = NULL;
 		}
 		return;
 	}
 	if (AgendaEntry::TypeNote == entry.type()) {
 		TRAP(
 				iError,
 				RPointerArray<CCalEntry> entryArray;
-				CleanupClosePushL(entryArray);
+CleanupResetAndDestroyPushL(entryArray);
 				// Get the global uid.
-				TTime homeTime;
+				CCalenInterimUtils2* calenInterimUtils2 = CCalenInterimUtils2::NewL();
-				homeTime.HomeTime();
+				HBufC8* globalUid = calenInterimUtils2->GlobalUidL();
-				TInt64 seed = homeTime.Int64();
+				CleanupStack::PushL(globalUid);
-				TInt randumNumber = Math::Rand(seed);
+				delete calenInterimUtils2;
-				HBufC8* globalUid = HBufC8::NewLC(KGuidLength);
-				globalUid->Des().Num(randumNumber);
 				// Construct a CCalEntry object and start filling the details.
 				CCalEntry* newEntry = 0;
 				newEntry = CCalEntry::NewL(
 						static_cast<CCalEntry::TType>(entry.type()),
 						globalUid,
 						static_cast<CCalEntry::TMethod>(entry.method()),
 						0);
 				CleanupStack::Pop(globalUid);
-				CleanupStack::PushL(newEntry);
 				// Add description.
 				TPtrC description(reinterpret_cast<const TUint16*>(
 						entry.description().utf16()));
 				newEntry->SetDescriptionL(description);
 				entryArray.AppendL(newEntry);
 				iCalEntryView->StoreL(entryArray, success);
 				localUid = newEntry->LocalUidL();
 				// Cleanup.
-				CleanupStack::PopAndDestroy(newEntry);
 				CleanupStack::PopAndDestroy(&entryArray);
 		)
 	} else {
 		TRAP(
 				iError,
 				RPointerArray<CCalEntry> entryArray;
-				CleanupClosePushL(entryArray);
+CleanupResetAndDestroyPushL(entryArray);
 				// Get the global uid.
 				TTime homeTime;
 				homeTime.HomeTime();
 				TInt64 seed = homeTime.Int64();
 						globalUid,
 						static_cast<CCalEntry::TMethod>(entry.method()),
 						0);
 				CleanupStack::Pop(globalUid);
-				CleanupStack::PushL(newEntry);
 				// Add the summary.
 				if (!entry.summary().isNull()) {
 					TPtrC summary(reinterpret_cast<const TUint16*>(
 							entry.summary().utf16()));
 				entryArray.AppendL(newEntry);
 				iCalEntryView->StoreL(entryArray, success);
 				localUid = newEntry->LocalUidL();
 				// Cleanup.
-				CleanupStack::PopAndDestroy(newEntry);
 				CleanupStack::PopAndDestroy(&entryArray);
 		)
 	}
 	// Emit signal upon successful creation of entry.
 	if (0 < localUid && 1 == success) {
 	if (AgendaEntry::TypeNote == type) {
 		TRAP(
 				iError,
 				RPointerArray<CCalEntry> entryArray;
-				CleanupClosePushL(entryArray);
+CleanupResetAndDestroyPushL(entryArray);
 				// Construct a CCalEntry object and start filling the details.
 				CCalEntry* newEntry = 0;
 				newEntry = CCalEntry::NewL(
 						static_cast<CCalEntry::TType>(type),
 						globalUid,
 						static_cast<CCalEntry::TMethod>(entry.method()),
 						0);
-				CleanupStack::PushL(newEntry);
 				// Add description.
 				TPtrC description(reinterpret_cast<const TUint16*>(
 						entry.description().utf16()));
 				newEntry->SetDescriptionL(description);
 				entryArray.AppendL(newEntry);
 				iCalEntryView->StoreL(entryArray, success);
 				localUid = newEntry->LocalUidL();
 				// Cleanup.
-				CleanupStack::PopAndDestroy(newEntry);
 				CleanupStack::PopAndDestroy(&entryArray);
 		)
 	} else {
 		TRAP(
 				iError,
 				RPointerArray<CCalEntry> entryArray;
-				CleanupClosePushL(entryArray);
+CleanupResetAndDestroyPushL(entryArray);
 				// Construct a CCalEntry object and start filling the details.
 				CCalEntry* newEntry = 0;
 				newEntry = CCalEntry::NewL(
 						static_cast<CCalEntry::TType>(type),
 						globalUid,
 						static_cast<CCalEntry::TMethod>(entry.method()),
 						0);
-				CleanupStack::PushL(newEntry);
 				// Add the summary.
 				if (!entry.summary().isNull()) {
 					TPtrC summary(reinterpret_cast<const TUint16*>(
 							entry.summary().utf16()));
 				entryArray.AppendL(newEntry);
 				iCalEntryView->StoreL(entryArray, success);
 				localUid = newEntry->LocalUidL();
 				// Cleanup.
-				CleanupStack::PopAndDestroy(newEntry);
 				CleanupStack::PopAndDestroy(&entryArray);
 		)
 	}
 	// Emit signal upon successful creation of entry.
 	if (0 < localUid && 1 == success) {
 				// Fetch the entries based on the global uid of the entry, as
 				// the exceptional entries share the global uid with the parent
 				// entry.
 				RPointerArray<CCalEntry> entries;
-				CleanupClosePushL(entries);
+				CleanupResetAndDestroyPushL(entries);
 				iCalEntryView->FetchL(calEntry->UidL(), entries);
 				if (entries.Count()) {
 				    iCalEntryView->DeleteL(*entries[0]);
 				}
-				// Cleanup.
-				int count = entries.Count();
-				for (int i = count - 1; i >= 0; --i) {
-					CCalEntry *entry = entries[i];
-					delete entry;
-				}
 				CleanupStack::PopAndDestroy(&entries);
 				CleanupStack::PopAndDestroy();
 			}
 	)
 				iError,
 				// Get the entry corresponding to the id.
 				AgendaEntry storedEntry = fetchById(entry.id());
 				CCalEntry* calEntry = iCalEntryView->FetchL(entry.id());
-				CleanupStack::PushL(calEntry);
 				// Update the description.
 				if (storedEntry.description() != entry.description()
 						&& !entry.description().isNull()) {
 					calEntry->SetDescriptionL(
 					calEntry->SetFavouriteL(entry.favourite());
 				}
 				// Update the entry using the CCalEntryView.
 				RPointerArray<CCalEntry> entryArray;
-				CleanupClosePushL(entryArray);
+				CleanupResetAndDestroyPushL(entryArray);
 				entryArray.AppendL(calEntry);
 				iCalEntryView->UpdateL(entryArray, success);
 				// Cleanup.
-				CleanupStack::PopAndDestroy(2, calEntry);
+				CleanupStack::PopAndDestroy( &entryArray );
 		)
 	} else {
 		TRAP(
 				iError,
 				// Get the entry corresponding to the id.
 				AgendaEntry storedEntry = fetchById(entry.id());
 				CCalEntry* calEntry = iCalEntryView->FetchL(entry.id());
-				CleanupStack::PushL(calEntry);
 				// Update the attendees.
 				if (!entry.isNull()
 						&& (entry.d->m_attendees != storedEntry.attendees())) {
-					RPointerArray<CCalAttendee> attendeesArray =
+					RPointerArray<CCalAttendee>& attendeesArray =
 							calEntry->AttendeesL();
-					CleanupClosePushL(attendeesArray);
 					int iterator = 0;
 					while (attendeesArray.Count() > iterator) {
 						calEntry->DeleteAttendeeL(iterator);
 						iterator++;
 					}
-					// Cleanup.
-					CleanupStack::PopAndDestroy(&attendeesArray);
 					addAttendeesToEntry(entry.d->m_attendees, *calEntry);
 				}
 				// Update the categories.
 				if (entry.d->m_categories != storedEntry.categories()) {
 					RPointerArray<CCalCategory> categories =
 							calEntry->CategoryListL();
-					CleanupClosePushL(categories);
 					int iterator = 0;
 					while (categories.Count() > iterator) {
 						calEntry->DeleteCategoryL(iterator);
 						iterator++;
 					}
-					// Cleanup.
-					CleanupStack::PopAndDestroy(&categories);
 					addCategoriesToEntry(entry.d->m_categories, *calEntry);
 				}
 				// Update the alarm.
 				}
 				calEntry->SetLastModifiedDateL();
 				// Save the geo value if any
 				AgendaGeoValue entryGeoValue = entry.geoValue();
-				if (!entryGeoValue.isNull()) {
+				if (!entryGeoValue.isNull() && (entryGeoValue != storedEntry.geoValue())) {
 					CCalGeoValue* geoValue = CCalGeoValue::NewL();
 					double latitude;
 					double longitude;
 					entryGeoValue.getLatLong(latitude, longitude);
 					geoValue->SetLatLongL(latitude, longitude);
 					// set it to CCalentry
 					calEntry->SetGeoValueL(*geoValue);
 					delete geoValue;
+				} else if (entryGeoValue.isNull()) {
+// Clear the geo values if any
+calEntry->ClearGeoValueL();
 				}
 				// Update the entry using the calen entry view.
 				RPointerArray<CCalEntry> entryArray;
-				CleanupClosePushL(entryArray);
+				CleanupResetAndDestroyPushL(entryArray);
 				entryArray.AppendL(calEntry);
 				if (!isChild) {
 					iCalEntryView->UpdateL(entryArray, success);
 				} else {
 					iCalEntryView->StoreL(entryArray, success);
 				}
 				// Cleanup.
-				CleanupStack::PopAndDestroy(2, calEntry);
+				CleanupStack::PopAndDestroy( &entryArray );
 		)
 	}
 	// Emit the signal to notify the clients.
 	if (0 < success) {
 	CCalEntry* calEntry;
 	if (instance) {
 		// Get all the entries with same global Uid.
 		RPointerArray<CCalEntry> entries;
-		CleanupClosePushL(entries);
+		CleanupResetAndDestroyPushL(entries);
 		iCalEntryView->FetchL(instance->UidL(), entries);
 		calEntry = entries[0];
+		entries.Remove(0);
 		CleanupStack::PopAndDestroy(&entries);
 	} else {
 		CleanupStack::PopAndDestroy(instance);
 		return false;
 	}
 	}
 	// Entry is not a child, but does it have any children?
 	// Fetch array of entries associated with this UID.
 	RPointerArray<CCalEntry> oldEntries;
-	CleanupClosePushL(oldEntries);
+	CleanupResetAndDestroyPushL(oldEntries);
 	iCalEntryView->FetchL(calEntry->UidL(), oldEntries);
 	bool hasChildren = oldEntries.Count() > 0;
 	// Before we proceed further update calEntry with the latest modifications
 	// Update only those fields that are required to copy to the children
 		geoValue->SetLatLongL(latitude, longitude);
 		// set it to CCalentry
 		calEntry->SetGeoValueL(*geoValue);
 		delete geoValue;
+	} else {
+// Clear the geo values
+calEntry->ClearGeoValueL();
 	}
 	// set the description
 	calEntry->SetDescriptionL(TPtrC(reinterpret_cast<const TUint16 *> (
 										entry.description().utf16())));
 	CleanupStack::PopAndDestroy( calEntry );
 	return success;
 }
-bool AgendaUtilPrivate::createException(const AgendaEntry& entry)
+bool AgendaUtilPrivate::createException(const AgendaEntry& entry,
-{
+										QDateTime instanceOriginalDateTime)
+{
 	// First prepare the session with agenda server.
 	if (!mInstanceViewCreated) {
 		// Something went wrong.
 		return false;
 	}
 				CleanupStack::PushL(calEntry);
 				// We are creating an exception, hence get the global Uid
 				HBufC8* guid = calEntry->UidL().AllocLC();
 				// create new (child) entry
 				// Use original instance time for recurrenceID as this entry hasn't got one.
-				TCalTime originalCalTime = calEntry->StartTimeL();
+				TCalTime originalCalTime;
+				TDateTime originalDateTime(instanceOriginalDateTime.date().year(),
+							TMonth(instanceOriginalDateTime.date().month() - 1),
+							instanceOriginalDateTime.date().day() -1, 0, 0, 0, 0);
+				TTime originalDateTimeTTime(originalDateTime);
+				originalCalTime.SetTimeLocalL(originalDateTimeTTime);
 				// create the new child now
 				CCalEntry* newEntry = CCalEntry::NewL( calEntry->EntryTypeL(),
 													   guid,
 													   calEntry->MethodL(),
 													   calEntry->SequenceNumberL(),
 													   originalCalTime,
 													   CalCommon::EThisOnly );
 				CleanupStack::Pop(guid);
 				CleanupStack::PopAndDestroy(calEntry);
-				CleanupStack::PushL(newEntry);
 				// Update the description.
 				if (!entry.description().isNull()) {
 					newEntry->SetDescriptionL(
 							TPtrC(reinterpret_cast<const TUint16 *> (
 				newEntry->SetFavouriteL(entry.favourite());
 				// Update the entry using the CCalEntryView.
 				RPointerArray<CCalEntry> entryArray;
-				CleanupClosePushL(entryArray);
+				CleanupResetAndDestroyPushL(entryArray);
 				entryArray.AppendL(newEntry);
 				iCalEntryView->StoreL(entryArray, success);
 				localUid = newEntry->LocalUidL();
 				// Cleanup.
-				CleanupStack::PopAndDestroy(2, newEntry);
+				CleanupStack::PopAndDestroy(&entryArray);
 		)
 	} else {
 		TRAP(
 				iError,
 				CleanupStack::PushL(calEntry);
 				// We are creating an exception, hence get the global Uid
 				HBufC8* guid = calEntry->UidL().AllocLC();
 				// create new (child) entry
 				// Use original instance time for recurrenceID as this entry hasn't got one.
-				TCalTime originalCalTime = calEntry->StartTimeL();
+				TCalTime originalCalTime;
+				TDateTime originalDateTime(instanceOriginalDateTime.date().year(),
+							TMonth(instanceOriginalDateTime.date().month() - 1),
+							instanceOriginalDateTime.date().day() -1, 0, 0, 0, 0);
+				TTime originalDateTimeTTime(originalDateTime);
+				originalCalTime.SetTimeLocalL(originalDateTimeTTime);
 				// create the new child now
 				CCalEntry* newEntry = CCalEntry::NewL( calEntry->EntryTypeL(),
 													   guid,
 													   calEntry->MethodL(),
 													   calEntry->SequenceNumberL(),
 													   originalCalTime,
 													   CalCommon::EThisOnly );
 				CleanupStack::Pop(guid);
 				CleanupStack::PopAndDestroy(calEntry);
-				CleanupStack::PushL(newEntry);
 				// Store the attendees.
 				if (!entry.isNull()) {
 					addAttendeesToEntry(entry.d->m_attendees, *newEntry);
 					addCategoriesToEntry(entry.d->m_categories, *newEntry);
 				}
 				// clear repeat rule properties
 				newEntry->ClearRepeatingPropertiesL();
 				// Update the entry using the calen entry view.
 				RPointerArray<CCalEntry> entryArray;
-				CleanupClosePushL(entryArray);
+				CleanupResetAndDestroyPushL(entryArray);
 				entryArray.AppendL(newEntry);
 				iCalEntryView->StoreL(entryArray, success);
 				localUid = newEntry->LocalUidL();
 				// Cleanup.
 				CleanupStack::PopAndDestroy(&entryArray);
-				CleanupStack::PopAndDestroy(newEntry);
 		)
 	}
 	// Emit the signal to notify the clients.
 	if (0 < success) {
 	TRAP(
 			iError,
 			RPointerArray<CCalInstance> instanceList;
-			CleanupClosePushL(instanceList);
+CleanupResetAndDestroyPushL(instanceList);
 			CalCommon::TCalViewFilter filters = filter;
 			TCalTime startDateForInstanceSearch;
 			TCalTime endDateForInstanceSearch;
 			TDateTime startTime = TDateTime(
 			for (int iter = 0; iter < instanceList.Count(); iter++) {
 				listOfIds.append(instanceList[iter]->Entry().LocalUidL());
 			}
-			int count = instanceList.Count();
-			for (int iter = count - 1; iter >= 0; --iter) {
-				CCalInstance *instance = instanceList[iter];
-				delete instance;
-			}
 			// Cleanup.
-			CleanupStack::PopAndDestroy();
+			CleanupStack::PopAndDestroy(&instanceList);
 	)
 	return listOfIds;
 }
 	TRAP(
 			iError,
 			RPointerArray<CCalInstance> instanceList;
-			CleanupClosePushL(instanceList);
+CleanupResetAndDestroyPushL(instanceList);
 			CalCommon::TCalViewFilter filters = filter;
 			TCalTime startDateForInstanceSearch;
 			TCalTime endDateForInstanceSearch;
 			TDateTime startTime = TDateTime(
 						createAgendaEntryFromCalEntry(
 								instanceList[iter]->Entry(),
 								instanceList[iter]));
 			}
-			int count = instanceList.Count();
-			for (int iter = count - 1; iter >= 0; --iter) {
-				CCalInstance *instance = instanceList[iter];
-				delete instance;
-			}
 			// Cleanup.
-			CleanupStack::PopAndDestroy();
+			CleanupStack::PopAndDestroy(&instanceList);
 	)
 	return entryList;
 }
 }
 TRAP(iError,
 RPointerArray<CCalInstance> instanceList;
-CleanupClosePushL(instanceList);
+CleanupResetAndDestroyPushL(instanceList);
 CalCommon::TCalViewFilter filters = filter;
 TCalTime startDateForInstanceSearch;
 TCalTime endDateForInstanceSearch;
 TDateTime startTime(rangeStart.date().year(),
 for(TInt i = 0; i<instanceList.Count(); i++)
 {
 entryList.append(createAgendaEntryFromCalEntry(instanceList[i]->Entry(), instanceList[i]));
 }
-int count = instanceList.Count();
+CleanupStack::PopAndDestroy(&instanceList);
-for (int i = count - 1; i >= 0; --i) {
-CCalInstance *instance = instanceList[i];
-delete instance;
-}
-CleanupStack::PopAndDestroy();
 )
 return entryList;
 }
 	if(!mInstanceViewCreated) {
 	    // return empty list
 	    return;
 	}
-	CleanupClosePushL(instanceList);
+	CleanupResetAndDestroyPushL(instanceList);
 	CalCommon::TCalViewFilter filters = filter;
 	TCalTime startDateForInstanceSearch;
 	TCalTime endDateForInstanceSearch;
 	TDateTime startTime(rangeStart.date().year(),
 	CalCommon::TCalTimeRange searchTimeRange(
 			startDateForInstanceSearch,
 			endDateForInstanceSearch);
 	iCalInstanceView->FindInstanceL(instanceList, filters, searchTimeRange);
 	// Parse thru the list and mark the dates which have events
 	for (int i = 0; i < instanceList.Count(); i++) {
 		CCalEntry::TType type = instanceList[i]->Entry().EntryTypeL();
 		// Get the start time and end time of the events
 		TCalTime startCalTime = instanceList[i]->StartTimeL();
 		TCalTime endCalTime = instanceList[i]->EndTimeL();
 		TDateTime startDateTime = startCalTime.TimeLocalL().DateTime();
-TDateTime endDateTime = endCalTime.TimeLocalL().DateTime();
+		TDateTime endDateTime = endCalTime.TimeLocalL().DateTime();
 		QDate startDate(startDateTime.Year(), startDateTime.Month()+1,
 						startDateTime.Day() + 1);
 QDate endDate(endDateTime.Year(), endDateTime.Month()+1,
 endDateTime.Day() + 1);
 		if (type == CCalEntry::EEvent || type == CCalEntry::EAppt ||
 				type == CCalEntry::EReminder) {
 			if(endsAtStartOfDay(instanceList[i], endCalTime.TimeLocalL())) {
-				// instance ends at start of endtime day, month view doesnt
-				// want to show event on this day
 				TDateTime endDateTime = endCalTime.TimeLocalL().DateTime();
+				// prevent problems with items ending tomorrow at 00:00
 				endDateTime.SetMinute(endDateTime.Minute() - 1);
 				TTime time(endDateTime);
+				// If it is ending before the start of the grid
 				if (time <= startDateForInstanceSearch.TimeLocalL()) {
 					continue;
 				}
 			}
 // Mark the required dates frm start date to end date
 TTimeIntervalDays days ;
+int numOfDays = 0;
 //check if the start date of the entry is before the start day of the grid
 if(startDate < rangeStart.date()){
 if(endDate<=rangeEnd.date()){
 //if the end date of entry is lying in the grid ,
 //then mark the entry from start day of the grid to the end date of the entry
 days = endCalTime.TimeLocalL().DaysFrom(startDateForInstanceSearch.TimeLocalL());
+numOfDays = days.Int();
 }
 else{
 //if end date of the entry is greater then the last date of grid,
 //then mark all the date of the grid with the entry
 days = endDateForInstanceSearch.TimeLocalL().DaysFrom(startDateForInstanceSearch.TimeLocalL()) ;
+numOfDays = days.Int();
 }
+// Check if the event is all-day
+if (instanceList[i]->Entry().EntryTypeL() == CCalEntry::EEvent) {
+// no need to consider the date on which it ends
+// reduce days count by 1
+numOfDays--;
+}
 //start the entries from the first day of the grid
-for (int j = 0; j <= days.Int(); j++) {
+for (int j = 0; j <= numOfDays; j++) {
 QDate date = rangeStart.date().addDays(j);
 if (date <= rangeEnd.date()) {
 dates.append(date);
 } else {
 break;
 else{
 if(endDate<=rangeEnd.date()){
 //if the end date of entry is lying in the grid ,
 //then mark the entry from start date of the entry to the end date of the entry
 days = endCalTime.TimeLocalL().DaysFrom(startCalTime.TimeLocalL()) ;
+numOfDays = days.Int();
 }
 else{
 //if end date of the entry is greater then the last date of grid,
 //then mark all the date from start date of the entry to the end date of the grid
 days = endDateForInstanceSearch.TimeLocalL().DaysFrom(startCalTime.TimeLocalL()) ;
+numOfDays = days.Int();
 }
-for (int j = 0; j <= days.Int(); j++) {
+// Check if the event is all-day
+if (instanceList[i]->Entry().EntryTypeL() == CCalEntry::EEvent) {
+// no need to consider the date on which it ends
+// reduce days count by 1
+numOfDays--;
+}
+for (int j = 0; j <= numOfDays; j++) {
 QDate date = startDate.addDays(j);
 if (date <= rangeEnd.date()) {
 dates.append(date);
 } else {
 break;
 } else {
 dates.append(startDate);
 }
 }
 }
-	int count = instanceList.Count();
+CleanupStack::PopAndDestroy(&instanceList);
-	for (int i = count - 1; i >= 0; --i) {
-	            CCalInstance *instance = instanceList[i];
-	            delete instance;
-	        }
-CleanupStack::PopAndDestroy();
 }
 QList<AgendaEntry> AgendaUtilPrivate::createEntryIdListForDay( QDateTime day,
 AgendaUtil::FilterFlags filter )
 {
 TCalTime dummy;
 CalCommon::TCalTimeRange dayRange( dummy, dummy );
 TRAP(iError,
 getDayRange(day, day, dayRange);
 RPointerArray<CCalInstance> instanceList;
-CleanupClosePushL(instanceList);
+CleanupResetAndDestroyPushL(instanceList);
 CalCommon::TCalViewFilter filters = filter;
 // Check if the filter has todos also to be included
 if(filter & CalCommon::EIncludeIncompletedTodos)
 {
 // Show the incompleted todos till date only for the current date
 }
 else
 {
 iCalInstanceView->FindInstanceL(instanceList, filters, dayRange);
 }
+// In this list, check if any all day events are there
+// As all day events end at 12.00AM of next day, we should not show it again on next day
+TCalTime calTime;
+TDateTime dateTime(
+day.date().year(),
+static_cast<TMonth>(day.date().month() - 1),
+day.date().day() - 1, day.time().hour(),
+day.time().minute(), 0, 0);
+TTime time(dateTime);
+for (int i(0); i < instanceList.Count(); i++) {
+if ((endsAtStartOfDay(instanceList[i], time)) &&
+instanceList[i]->Entry().EntryTypeL() == CCalEntry::EEvent) {
+// Previous day all-day event has been found, we are not supposed to
+// show it on current day, hence remove it from the instance list
+instanceList.Remove(i);
+i--;
+}
+}
 // Sort the list
 sortInstanceList(instanceList);
 for(TInt i = 0; i<instanceList.Count(); i++)
 {
 entryList.append(createAgendaEntryFromCalEntry(
 instanceList[i]->Entry(), instanceList[i]));
 }
-int count = instanceList.Count();
+CleanupStack::PopAndDestroy( &instanceList );
-for (int i = count - 1; i >= 0; --i) {
-CCalInstance *instance = instanceList[i];
-delete instance;
-}
-CleanupStack::PopAndDestroy();
 )
 return entryList;
 }
 			calTime.SetTimeLocalL(time);
 			// Fetch the calentry
 			CCalEntry* calEntry = iCalEntryView->FetchL(entry.id());
-			CleanupStack::PushL(calEntry);
 			calEntry->SetCompletedL(complete, calTime);
 			// Update the entry in the Database
 			RPointerArray<CCalEntry> array;
-			CleanupClosePushL(array);
+			CleanupResetAndDestroyPushL(array);
 			array.AppendL(calEntry);
 			iCalEntryView->UpdateL(array, success);
 			// Cleanup.
-			CleanupStack::PopAndDestroy(&array);
+			CleanupStack::PopAndDestroy( &array );
-			CleanupStack::PopAndDestroy(calEntry);
 	)
 	if (0 < success) {
 		emit q->entryUpdated(entry.id());
 	}
 			CCalEntry* calEntry = iCalEntryView->FetchL(entry.id());
 			if (calEntry) {
 				// Get all the entries with same global Uid.
 				RPointerArray<CCalEntry> entries;
-				CleanupClosePushL(entries);
+				CleanupResetAndDestroyPushL(entries);
 				iCalEntryView->FetchL(calEntry->UidL(), entries);
 				parentEntry = createAgendaEntryFromCalEntry(*entries[0]);
 				CleanupStack::PopAndDestroy(&entries);
 			}
 	)
 	CCalEntry* calEntry = iCalEntryView->FetchL(entry.id());
 	if (calEntry) {
 		// Get all the entries with same global Uid.
 		RPointerArray<CCalEntry> entries;
-		CleanupClosePushL(entries);
+		CleanupResetAndDestroyPushL(entries);
 		iCalEntryView->FetchL(calEntry->UidL(), entries);
 		entries[0]->ClearRepeatingPropertiesL();
 		CleanupStack::PopAndDestroy(&entries);
 	}
 }
 void AgendaUtilPrivate::getPreviousInstanceTimes(AgendaEntry& entry,
 												QDateTime& startTime,
 												QDateTime& endTime)
 {
 	RPointerArray<CCalEntry> entries;
-	CleanupClosePushL(entries);
+	CleanupResetAndDestroyPushL(entries);
 	TCalTime previousStartTime;
 	TCalTime previousEndTime;
 	TTime zero(TInt64(0));
 	// Fetch the parent entry
 	// Get the CalEntry equivalent of the entry.
 					break;
 			}
 			// Is currentInstanceDate before parent dt start?
 			if (currentInstanceDate.TimeLocalL() <
 					entries[0]->StartTimeL().TimeLocalL()) {
+				TBool exceptionEntryBeforeParentStartPresent = EFalse;
+				for (TInt i=0; i<exdates.Count(); ++i) {
+					if( exdates[i].TimeLocalL() < currentInstanceDate.TimeLocalL() ) {
+						exceptionEntryBeforeParentStartPresent = ETrue;
+					}
+				}
+				if (!exceptionEntryBeforeParentStartPresent) {
+					currentInstanceDate.SetTimeLocalL(Time::NullTTime());
+					previousStartTime = currentInstanceDate;
+				}
 				// There are no instances before the exception
 				keepLooking = EFalse;
 			} else {
 				// TODO: Put the rest of this function into a separate function, as it's identical
 				// to GetNextInstanceTimeL().
 				}
 			}
 		}
 		CleanupStack::PopAndDestroy(&exdates);
 	}
-	// Convert TCalTimes to QDateTimes
-	TDateTime prevStart = previousStartTime.TimeLocalL().DateTime();
+	if(previousStartTime.TimeUtcL() != Time::NullTTime()) {
-	TDateTime prevEnd = previousEndTime.TimeLocalL().DateTime();
+		// Convert TCalTimes to QDateTimes
-	startTime.setDate(QDate(prevStart.Year(), prevStart.Month()+1,
+		TDateTime prevStart = previousStartTime.TimeLocalL().DateTime();
-					prevStart.Day() + 1));
+		TDateTime prevEnd = previousEndTime.TimeLocalL().DateTime();
-	startTime.setTime(QTime(prevStart.Hour(), prevStart.Minute(), 0, 0));
+		startTime.setDate(QDate(prevStart.Year(), prevStart.Month()+1,
-	endTime.setDate(QDate(prevEnd.Year(), prevEnd.Month()+1,
+		                        prevStart.Day() + 1));
-	                      prevEnd.Day() + 1));
+		startTime.setTime(QTime(prevStart.Hour(), prevStart.Minute(), 0, 0));
-	endTime.setTime(QTime(prevEnd.Hour(), prevEnd.Minute(), 0, 0));
+		endTime.setDate(QDate(prevEnd.Year(), prevEnd.Month()+1,
+		                      prevEnd.Day() + 1));
+		endTime.setTime(QTime(prevEnd.Hour(), prevEnd.Minute(), 0, 0));
+	} else {
+		QDateTime nullDateTime;
+		startTime = nullDateTime;
+		endTime = nullDateTime;
+	}
 	delete calEntry;
-	int count = entries.Count();
-	for (int i = count - 1; i >= 0; --i) {
-		CCalEntry *instance = entries[i];
-		delete instance;
-	}
 	CleanupStack::PopAndDestroy(&entries);
 }
 /*!
 	Returns the start and end times of next occurence of a particular
 void AgendaUtilPrivate::getNextInstanceTimes(AgendaEntry& entry,
 QDateTime& startTime,
 QDateTime& endTime)
 {
 	RPointerArray<CCalEntry> entries;
-	CleanupClosePushL(entries);
+	CleanupResetAndDestroyPushL(entries);
 	TCalTime nextStartTime;
 	TCalTime nextEndTime;
 	TTime zero(TInt64(0));
 	// Fetch the parent entry
 	// Get the CalEntry equivalent of the entry.
 				default:
 				case notRepeated:
 					keepLooking = EFalse;
 					break;
 			}
-			// Is currentInstanceDate before parent dt start?
+			// Is currentInstanceDate after repeat until date?
-			if (currentInstanceDate.TimeLocalL() <
+			if (currentInstanceDate.TimeLocalL() >
-					entries[0]->StartTimeL().TimeLocalL()) {
+					rrule.Until().TimeLocalL()) {
+				TBool exceptionEntryAfterRepeatUntilPresent = EFalse;
+				for (TInt i=0; i<exdates.Count(); ++i) {
+					if(exdates[i].TimeLocalL() > rrule.Until().TimeLocalL()) {
+						exceptionEntryAfterRepeatUntilPresent = ETrue;
+					}
+				}
+				if (!exceptionEntryAfterRepeatUntilPresent) {
+					currentInstanceDate.SetTimeLocalL(Time::NullTTime());
+					nextStartTime = currentInstanceDate;
+				}
 				// There are no instances before the exception
 				keepLooking = EFalse;
 			} else {
 				// TODO: Put the rest of this function into a separate function, as it's identical
 				// to GetNextInstanceTimeL().
 				}
 			}
 		CleanupStack::PopAndDestroy( &exdates );
 		}
 	}
-	// Convert TCalTimes to QDateTimes
-	TDateTime nextStart = nextStartTime.TimeLocalL().DateTime();
+	if (nextStartTime.TimeUtcL() != Time::NullTTime()) {
-	TDateTime nextEnd = nextEndTime.TimeLocalL().DateTime();
+		// Convert TCalTimes to QDateTimes
-	startTime.setDate(QDate(nextStart.Year(), nextStart.Month()+1,
+		TDateTime nextStart = nextStartTime.TimeLocalL().DateTime();
-	                        nextStart.Day() + 1));
+		TDateTime nextEnd = nextEndTime.TimeLocalL().DateTime();
-	startTime.setTime(QTime(nextStart.Hour(), nextStart.Minute(), 0, 0));
+		startTime.setDate(QDate(nextStart.Year(), nextStart.Month()+1,
-	endTime.setDate(QDate(nextEnd.Year(), nextEnd.Month()+1,
+		                        nextStart.Day() + 1));
-	                      nextEnd.Day() + 1));
+		startTime.setTime(QTime(nextStart.Hour(), nextStart.Minute(), 0, 0));
-	endTime.setTime(QTime(nextEnd.Hour(), nextEnd.Minute(), 0, 0));
+		endTime.setDate(QDate(nextEnd.Year(), nextEnd.Month()+1,
+		                      nextEnd.Day() + 1));
+		endTime.setTime(QTime(nextEnd.Hour(), nextEnd.Minute(), 0, 0));
+	} else {
+		QDateTime nullDateTime;
+		startTime = nullDateTime;
+		endTime = nullDateTime;
+	}
 	delete calEntry;
-	int count = entries.Count();
-		for (int i = count - 1; i >= 0; --i) {
-			CCalEntry *instance = entries[i];
-			delete instance;
-		}
 	CleanupStack::PopAndDestroy(&entries);
 }
 /*!
 	 Returns true if there are no entries in the database else returns false
 	}
 	bool isEmpty;
 	// Query for the entries for entire range
 	RPointerArray<CCalInstance> instanceList;
-	CleanupClosePushL(instanceList);
+	CleanupResetAndDestroyPushL(instanceList);
 	// Create the filter
 	CalCommon::TCalViewFilter filters = AgendaUtil::IncludeAnniversaries
 										| AgendaUtil::IncludeAppointments
 										| AgendaUtil::IncludeEvents
 	if (instanceList.Count()) {
 		isEmpty = false;
 	} else {
 		isEmpty = true;
 	}
-	int count = instanceList.Count();
-	for (int i = count - 1; i >= 0; --i) {
+	// Cleanup
-	            CCalInstance *instance = instanceList[i];
+	CleanupStack::PopAndDestroy( &instanceList );
-	            delete instance;
-	        }
-	CleanupStack::PopAndDestroy();
 	return isEmpty;
 }
 /*!
 	Returns the minimum time supported.
 			QTime(
 					calEndDateTime.Hour(), calEndDateTime.Minute(), 0, 0));
 	entry.setStartAndEndTime(startDateTime, endDateTime);
 	// Attendees.
-	RPointerArray<CCalAttendee> calAttendees = calEntry.AttendeesL();
+	RPointerArray<CCalAttendee>& calAttendees = calEntry.AttendeesL();
-	CleanupClosePushL(calAttendees);
 	for (int i = 0; i < calAttendees.Count(); i++) {
 		AgendaAttendee attendee;
 		// Address.
 		TPtrC calAddress = calAttendees[i]->Address();
 		attendee.setStatus(
 				static_cast<AgendaAttendee::StatusType>(
 						calAttendees[i]->StatusL()));
 		entry.addAttendee(attendee);
 	}
-	CleanupStack::Pop(&calAttendees);
 	// Categories.
-	RPointerArray<CCalCategory> calCategories = calEntry.CategoryListL();
+	const RPointerArray<CCalCategory>& calCategories = calEntry.CategoryListL();
-	CleanupClosePushL(calCategories);
 	for (int i = 0; i < calCategories.Count(); i++) {
 		AgendaCategory category;
 		CCalCategory::TCalCategoryType categoryType =
 				calCategories[i]->Category();
 		}
 		category.setCategory(
 				static_cast<AgendaCategory::CategoryType>(categoryType));
 		entry.addCategory(category);
 	}
-	CleanupStack::PopAndDestroy(&calCategories);
 	// Id.
 	entry.d->m_id = calEntry.LocalUidL();
 	// Alarm.
 }
 	TCalTime dummy;
 	CalCommon::TCalTimeRange dayRange(dummy, dummy);
 	getDayRange(entry.startTime(), entry.startTime(), dayRange);
 	RPointerArray<CCalInstance> instances;
-	CleanupClosePushL(instances);
+	CleanupResetAndDestroyPushL(instances);
 	iCalInstanceView->FindInstanceL(instances, CalCommon::EIncludeAll, dayRange);
 	TTime entryStartTime(dayRange.StartTime().TimeLocalL());
 	CCalInstance* result = 0;
 TTime AgendaUtilPrivate::getPreviousInstanceForRepeatOther(CCalEntry& entry,
 									const CalCommon::TCalTimeRange& timeRange)
 {
 	RPointerArray<CCalInstance> allInstances;
-	CleanupClosePushL( allInstances );
+	CleanupResetAndDestroyPushL(allInstances);
 	TInt filter;
 	// Get the entry type to be filtered
 	switch(entry.EntryTypeL())
 		{
 TTime AgendaUtilPrivate::getNextInstanceForRepeatOther(CCalEntry& aEntry,
 								   const CalCommon::TCalTimeRange& timeRange)
 {
 	RPointerArray<CCalInstance> allInstances;
-	CleanupClosePushL( allInstances );
+	CleanupResetAndDestroyPushL(allInstances);
 TInt filter;
 // Get the entry type to be filtered
 switch(aEntry.EntryTypeL())
 {
 entry.UidL().AllocL(),
 oldEntries[i]->MethodL(),
 oldEntries[i]->SequenceNumberL(),
 recId,
 oldEntries[i]->RecurrenceRangeL() );
-CleanupStack::PushL(exception);
 exception->CopyFromL(*oldEntries[i]);
 exception->SetLastModifiedDateL();
 TInt successCount=0;
 			RPointerArray<CCalEntry> entries;
-			CleanupClosePushL( entries );
+			CleanupResetAndDestroyPushL(entries);
 			entries.Append( exception );
 			iCalEntryView->StoreL( entries, successCount );
 			CleanupStack::PopAndDestroy( &entries );
-CleanupStack::PopAndDestroy(exception);
 }
 else
 {
 // If the start time of the series has been changed, the call below will
 // leave with -1, and the child entries will be lost.  To prevent this
 // Fixing this may cause issues with sync though, as some servers delete the
 // children when changing the start time of the series anyway.
 	oldEntries[i]->SetLastModifiedDateL();
 			TInt successCount=0;
 			RPointerArray<CCalEntry> entries;
-			CleanupClosePushL( entries );
+			CleanupClosePushL(entries);
 			entries.Append( oldEntries[i] );
 			iCalEntryView->StoreL( entries, successCount );
-			CleanupStack::PopAndDestroy( &entries );
+			CleanupStack::Pop( &entries );
 }
 }
 }
 TCalTime AgendaUtilPrivate::generateRecurrenceIdFromEntry( CCalEntry& entry,

changeset 49	5de72ea7a065
parent 37	360d55486d7f
child 50	579cc610882e