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

equal deleted inserted replaced

-:ecd7b9840282
+:0b38fc5b94c6
 #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
 // Local constants
 const TInt KEntriesToDelete = 1;
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 CalenDeleteUi* CalenDeleteUi::NewL( CCalenController& aController )
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_NEWL_ENTRY );
 CalenDeleteUi* self = new( ELeave ) CalenDeleteUi( aController, NULL );
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop( self );
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_NEWL_EXIT );
 return self;
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::CalenDeleteUi
 // ----------------------------------------------------------------------------
 //
 CalenDeleteUi::CalenDeleteUi( CCalenController& aController, QObject *parent )
 :QObject(parent), iController( aController )
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_CALENDELETEUI_ENTRY );
 iIsDeleting = false;
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_CALENDELETEUI_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::~CalenDeleteUi
 // Destructor
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 CalenDeleteUi::~CalenDeleteUi()
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( DUP1_CALENDELETEUI_CALENDELETEUI_ENTRY );
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( DUP1_CALENDELETEUI_CALENDELETEUI_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::ConstructL
 // Second phase of construction
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::ConstructL()
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_CONSTRUCTL_ENTRY );
 iController.RegisterForNotificationsL( this, ECalenNotifyCancelDelete );
 iMoreEntriesToDelete = EFalse;
 iDisplayQuery = EFalse;
 iEntriesToDelete = KEntriesToDelete;
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_CONSTRUCTL_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::HandleNotification
 // Handles notifications.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::HandleNotification(const TCalenNotification aNotification )
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_HANDLENOTIFICATION_ENTRY );
 if( aNotification == ECalenNotifyCancelDelete)
 {
 if(iMutlipleContextIdsCount)
 {
 // reset the multiple contexts
 context.resetMultipleContextIds();
 }
 }
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_HANDLENOTIFICATION_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::HandleCommandL
 // Handles action ui commands
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 TBool CalenDeleteUi::HandleCommandL( const TCalenCommand& aCommand )
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_HANDLECOMMANDL_ENTRY );
 TBool continueCommand(EFalse);
 switch( aCommand.Command() )
 {
 case ECalenDeleteCurrentEntry:
 // command but it wasn't in our list; something has gone wrong.
 //ASSERT( EFalse );
 break;
 }
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_HANDLECOMMANDL_EXIT );
 return continueCommand;
 }
 // ----------------------------------------------------------------------------
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DeleteThisOrAllL( AgendaUtil::RecurrenceRange aRepeatType )
 {
-	TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DELETETHISORALLL_ENTRY );
 	if( iController.context().instanceId().mEntryLocalUid )
 	{
 		AgendaEntry instance = CalenActionUiUtils::findPossibleInstanceL(
 									iController.context().instanceId(),
 		if( !instance.isNull() )
 		{
 			DeleteSingleInstanceL( instance, aRepeatType );
 		}
 	}
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( CALENDELETEUI_DELETETHISORALLL_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::DeleteEntryWithoutQueryL()
 // Deletes the current entry
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 TBool CalenDeleteUi::DeleteEntryWithoutQueryL()
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRYWITHOUTQUERYL_ENTRY );
 	bool continueCommand(EFalse);
 	// get the context
 	MCalenContext& context = iController.context();
 context.resetMultipleContextIds();
 // notify delete failed
 iController.BroadcastNotification(ECalenNotifyDeleteFailed);
 }
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRYWITHOUTQUERYL_EXIT );
 return continueCommand;
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::DeleteCurrentEntryL
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DeleteCurrentEntryL()
 {
-	TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DELETECURRENTENTRYL_ENTRY );
 	// 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);
 					// Save the entry for later reference in the slot
 					showDeleteQuery(EDeleteEntry);
 				}
 			}
 	}
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( CALENDELETEUI_DELETECURRENTENTRYL_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::DeleteAllEntriesL
 // Deletes all entries
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DeleteAllEntriesL()
 {
+OstTraceFunctionEntry0( CALENDELETEUI_DELETEALLENTRIESL_ENTRY );
 	if(iIsDeleting) {
+		OstTraceFunctionExit0( CALENDELETEUI_DELETEALLENTRIESL_EXIT );
 		return;
 	}
 showDeleteQuery(EDeleteAll );
+	OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETEALLENTRIESL_EXIT );
 	}
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::DeleteEntriesBeforeDateL
 // Deletes all entries before a set date.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DeleteEntriesBeforeDateL()
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRIESBEFOREDATEL_ENTRY );
 	if(iIsDeleting) {
+		OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRIESBEFOREDATEL_EXIT );
 		return;
 	}
 // launch the datepicker
 dateQuery();
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETEENTRIESBEFOREDATEL_EXIT );
 }
 // ----------------------------------------------------------------------------
 // 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->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()) {
 		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 );
 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());
 				iController.Services().agendaInterface()->deleteRepeatedEntry(
 									instance, AgendaUtil::ThisAndAll);
 				break;
 		}
 	}
+	OstTraceFunctionExit0( CALENDELETEUI_HANDLEREPEATEDENTRYDELETE_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::showDeleteQuery
 // Launches the popup for deleting the instance/instances
 // ----------------------------------------------------------------------------
 //
 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 );
 popup->removeAction(list[i]);
 }
 mDeleteAction = new HbAction(
 						hbTrId("txt_calendar_button_dialog_delete"), popup);
 popup->addAction(mDeleteAction);
-mCancelAction = new HbAction(hbTrId("txt_calendar_button_cancel"), popup);
+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) {
 	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
 // Handles multiple delete events
 //
 void CalenDeleteUi::HandleDeleteMultipleEventsL( const QDateTime& aFirstDay,
 const QDateTime& aLastDay,
 int aConfNoteId )
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_HANDLEDELETEMULTIPLEEVENTSL_ENTRY );
 	if(iIsDeleting) {
+		OstTraceFunctionExit0( CALENDELETEUI_HANDLEDELETEMULTIPLEEVENTSL_EXIT );
 		return;
 	}
 iConfirmationNoteId = aConfNoteId;
 DeleteDayRangeL( aFirstDay, aLastDay );
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( DUP1_CALENDELETEUI_HANDLEDELETEMULTIPLEEVENTSL_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::DeleteDayRangeL
 // Deletes all entries in a given range.
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DeleteDayRangeL( const QDateTime& aStart,
 const QDateTime& aEnd )
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DELETEDAYRANGEL_ENTRY );
 iStartTime = aStart;
 iEndTime = aEnd;
 iIsDeleting = ETrue;
 	                | AgendaUtil::IncludeReminders
 	                | AgendaUtil::IncludeIncompletedTodos);
 // 1: First pass, delete all entries.
 iController.agendaInterface()->deleteEntries(iStartTime, iEndTime, filter);
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_DELETEDAYRANGEL_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenDeleteUi::DoCompletedL
 // Handles delete callback
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenDeleteUi::doCompleted( int aFirstPassError )
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DOCOMPLETED_ENTRY );
 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
 // 3. End deleting, close wait dialog, and show confirmation or error note
 iIsDeleting = EFalse;
 iController.BroadcastNotification( ECalenNotifyMultipleEntriesDeleted );
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_DOCOMPLETED_EXIT );
 }
 // ----------------------------------------------------------------------------
 // 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;
+OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRIESENDINGATMIDNIGHT_ENTRY );
 QDateTime start, end;
 QTime startTime(aMidnight.time());
 startTime.setHMS(startTime.hour(), startTime.minute() - 1,
 startTime.second(), startTime.msec());
 iController.Services().agendaInterface()->deleteRepeatedEntry(entry, AgendaUtil::ThisAndAll);
 }
 }
 }
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRIESENDINGATMIDNIGHT_EXIT );
 }
 // -----------------------------------------------------------------------------
 // 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;
+OstTraceFunctionEntry0( CALENDELETEUI_DELETESINGLEINSTANCEL_ENTRY );
 DoDeleteSingleInstanceL( aInstance, EFalse, AgendaUtil::ThisAndAll );
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_DELETESINGLEINSTANCEL_EXIT );
 }
 // -----------------------------------------------------------------------------
 // CalenDeleteUi::DeleteSingleInstanceL
 // Delete the given instance. Delete the entry range given by aRepeatType.
 // -----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DeleteSingleInstanceL( AgendaEntry& aInstance,
 AgendaUtil::RecurrenceRange aRepeatType )
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( DUP1_CALENDELETEUI_DELETESINGLEINSTANCEL_ENTRY );
 DoDeleteSingleInstanceL( aInstance, ETrue, aRepeatType );
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( DUP1_CALENDELETEUI_DELETESINGLEINSTANCEL_EXIT );
 }
 // -----------------------------------------------------------------------------
 // CalenDeleteUi::DoDeleteSingleInstanceL
 // Performs the deletion of the instance. If aHasRepeatType is EFalse, the user
 void CalenDeleteUi::DoDeleteSingleInstanceL(
 									AgendaEntry& aInstance,
 									bool aHasRepeatType,
 									AgendaUtil::RecurrenceRange aRepeatType )
 {
-	TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DODELETESINGLEINSTANCEL_ENTRY );
 	bool repeating = aInstance.isRepeating();
 	if( !repeating ) {
 		// Even though there is no RRule, the entry might
 		// have a list of rdates.
 	{
 		showDeleteQuery(aInstance.type() == AgendaEntry::TypeTodo ?
 														EDeleteToDo :
 														EDeleteEntry );
 	}
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( CALENDELETEUI_DODELETESINGLEINSTANCEL_EXIT );
 }
 // -----------------------------------------------------------------------------
 // CalenDeleteUi::DialogDismissedL
 // called when a dialog is dismissed.
 // -----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DialogDismissedL( const TInt /*aButtonId*/ )
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DIALOGDISMISSEDL_ENTRY );
 // no more entries to delete
 iMoreEntriesToDelete = EFalse;
 iDisplayQuery = EFalse;
 // issue notification cancel delete
 iController.BroadcastNotification(ECalenNotifyCancelDelete);
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_DIALOGDISMISSEDL_EXIT );
 }
 // -----------------------------------------------------------------------------
 // CalenDeleteUi::DeleteEntryL
 // Delete entry using entry local uid
 // -----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DeleteEntryL(ulong& aEntryLocalUid)
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DELETEENTRYL_ENTRY );
 iController.Services().agendaInterface()->deleteEntry(aEntryLocalUid);
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_DELETEENTRYL_EXIT );
 }
 // -----------------------------------------------------------------------------
 // CalenDeleteUi::DisplayWaitDialogL
 // Display wait dialog
 // -----------------------------------------------------------------------------
 //
 void CalenDeleteUi::DisplayWaitDialogL()
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_DISPLAYWAITDIALOGL_ENTRY );
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_DISPLAYWAITDIALOGL_EXIT );
 }
 // -----------------------------------------------------------------------------
 // CalenDeleteUi::MarkedEntriesDeletedL
 // Dismiss wait dialog and show information note
 // -----------------------------------------------------------------------------
 //
 void CalenDeleteUi::MarkedEntriesDeletedL()
 {
-TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENDELETEUI_MARKEDENTRIESDELETEDL_ENTRY );
 // notify marked entries deleted
 iController.BroadcastNotification( ECalenNotifyMarkedEntryDeleted );
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENDELETEUI_MARKEDENTRIESDELETEDL_EXIT );
 }
 // End of File

changeset 51	0b38fc5b94c6
parent 45	b6db4fd4947b
child 55	2c54b51f39c4