FCL/sf/app/organizer: comparison calendarui/caleneditor/src/caleneditor

equal deleted inserted replaced

-:ecd7b9840282
+:0b38fc5b94c6
 #include "caleneditorcommon.h"
 #include "calendateutils.h"
 #include "caleneditordatahandler.h"
 #include "caleneditorreminderfield.h"
 #include "caleneditorrepeatfield.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "caleneditor_pTraces.h"
+#endif
 /*!
 	\class CalenEditorPrivate
 	This object loads the calendar editor view. The view is added to the top
 	of the HbMainWindow.
 									mIsChild(false),
 									mIsAllDayItemAdded(false),
 									mLaunchCalendar(false),
 									mMenuItemAdded(false)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_CALENEDITORPRIVATE_ENTRY );
 	// First get the q-pointer.
 	q_ptr = static_cast<CalenEditor *> (parent);
 	mMainWindow = NULL;
 	mTranslator->loadCommon();
 		mOwnsAgendaUtil = true;
 	} else {
 		mAgendaUtil = agendaUtil;
 		mOwnsAgendaUtil = false;
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_CALENEDITORPRIVATE_EXIT );
 }
 /*!
 	Destructor.
 */
 CalenEditorPrivate::~CalenEditorPrivate()
 {
+	OstTraceFunctionEntry0( DUP1_CALENEDITORPRIVATE_CALENEDITORPRIVATE_ENTRY );
 	if(mOwnsAgendaUtil) {
 		delete mAgendaUtil;
 		mAgendaUtil = NULL;
 	}
 	if (mOriginalEntry) {
 	// delete the mainwindow object if created any
 	if (mMainWindow) {
 		delete mMainWindow;
 		mMainWindow = NULL;
 	}
+	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_CALENEDITORPRIVATE_EXIT );
 }
 /*!
 	Shows the caleneditor by parsing a .vcs.
 	\param handle reference to QFile handle.
 */
 void CalenEditorPrivate::edit(const QFile &/*handle*/, bool launchCalendar)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_EDIT_ENTRY );
 	// TODO: Needs to be implemented using importer.
 	mNewEntry = false;
 	mLaunchCalendar = launchCalendar;
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_EDIT_EXIT );
 }
 /*!
 	Shows the caleneditor, by parsing an AgendaEntry.
 	\param entry An object of AgendaEntry.
 */
 void CalenEditorPrivate::edit(AgendaEntry entry, bool launchCalendar)
 {
+	OstTraceFunctionEntry0( DUP1_CALENEDITORPRIVATE_EDIT_ENTRY );
 	mNewEntry = false;
 	mLaunchCalendar = launchCalendar;
 	openEditor(entry);
+	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_EDIT_EXIT );
 }
 /*!
 	Shows the caleneditor, by using the entry id provided.
 	\param id entry id.
 */
 void CalenEditorPrivate::edit(ulong id, bool launchCalendar)
 {
+	OstTraceFunctionEntry0( DUP2_CALENEDITORPRIVATE_EDIT_ENTRY );
 	mNewEntry = false;
 	AgendaEntry entry = mAgendaUtil->fetchById(id);
 	if(entry.isNull()) {
+		OstTraceFunctionExit0( DUP2_CALENEDITORPRIVATE_EDIT_EXIT );
 		return;
 	}
 	edit(entry, launchCalendar);
+	OstTraceFunctionExit0( DUP3_CALENEDITORPRIVATE_EDIT_EXIT );
 }
 /*!
 	Creates a new entry based on the create type.It launches the
 	editor for editing
 	\QDateTime newEntryDateTime is the event start time.
 */
 void CalenEditorPrivate::create(CalenEditor::CreateType type,
 QDateTime newEntryDateTime, bool launchCalendar)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_CREATE_ENTRY );
 	mNewEntryDateTime = newEntryDateTime;
 	mNewEntry = true;
 	AgendaEntry entry;
 	switch(type){
 		case CalenEditor::TypeAppointment: {
 			entry.setType(AgendaEntry::TypeAppoinment);
 			break;
 	}
 	mLaunchCalendar = launchCalendar;
 	openEditor(entry);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_CREATE_EXIT );
 }
 /*!
 	Creates a new entry based on the create type.It launches the
 	editor for editing
 	\QDateTime newEntryDateTime is the event start time.
 */
 void CalenEditorPrivate::create(CalenEditor::CreateType type,
 AgendaEntry entry, bool launchCalendar)
 {
+	OstTraceFunctionEntry0( DUP1_CALENEDITORPRIVATE_CREATE_ENTRY );
 	mNewEntry = true;
 	switch(type){
 		case CalenEditor::TypeAppointment: {
 			entry.setType(AgendaEntry::TypeAppoinment);
 		}
 			break;
 	}
 	mNewEntryDateTime = entry.startTime();
 	mLaunchCalendar = launchCalendar;
 	openEditor(entry);
+	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_CREATE_EXIT );
 }
 /*!
 	Queries user whether to edit whole series or just this single occurence
 */
 void CalenEditorPrivate::showEditOccurencePopup()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SHOWEDITOCCURENCEPOPUP_ENTRY );
 	HbDialog *popUp = new HbDialog();
 	popUp->setDismissPolicy(HbDialog::NoDismiss);
 	popUp->setTimeout(HbDialog::NoTimeout);
 	popUp->setAttribute( Qt::WA_DeleteOnClose, true );
 	        SLOT(handleEditOccurence(int)));
 	connect(cancelAction, SIGNAL(triggered()), this, SLOT(handleCancel()));
 	// Show the popup
 	popUp->open();
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_SHOWEDITOCCURENCEPOPUP_EXIT );
 }
 /*!
 	Slot to handle User selection for series editing or single occurence popup
 */
 void CalenEditorPrivate::handleEditOccurence(int index)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLEEDITOCCURENCE_ENTRY );
 	switch (index) {
 		case 0:
 			// User wants to edit only this occurence
 			mEditRange = ThisOnly;
 			break;
 	AgendaEntry entryToBeEdited = mEntry;
 	if (mEditRange == ThisAndAll) {
 		entryToBeEdited = mAgendaUtil->parentEntry(mEntry);
 	}
 	showEditor(entryToBeEdited);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLEEDITOCCURENCE_EXIT );
 }
 /*!
 	Slot to handle cancel action on the popup
 */
 void CalenEditorPrivate::handleCancel()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLECANCEL_ENTRY );
 	// User has chosen not to edit the event, hence return
 	mEditRange = UserCancelled;
 	// Do cleanup and return
 	emit q_ptr->dialogClosed();
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLECANCEL_EXIT );
 	return;
 }
 /*!
 	Opens the editor.
 */
 void CalenEditorPrivate::openEditor(AgendaEntry entry)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_OPENEDITOR_ENTRY );
 	if (0 < entry.id()) {
 		mNewEntry = false;
 	}
 	if (!mNewEntry) {
 		// Before we do anything, check in the entry is repeating
 		mEntry = entry;
 		if (mIsChild || isRepeating) {
 			// Query user if he wants to edit whole series
 			// or just this occurence
 			showEditOccurencePopup();
+			OstTraceFunctionExit0( CALENEDITORPRIVATE_OPENEDITOR_EXIT );
 			return;
 		}else {
 			mEditRange = ThisAndAll;
 		}
 	}
 	showEditor(entry);
+	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_OPENEDITOR_EXIT );
 }
 /*!
 	Displays the editor.
 */
 void CalenEditorPrivate::showEditor(AgendaEntry entry)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SHOWEDITOR_ENTRY );
 	mOriginalEntry = new AgendaEntry(entry);
 	mEditedEntry = new AgendaEntry(entry);
 	if (!mEditedEntry->description().isEmpty()) {
 		mDescriptionItemAdded = true;
 	connect(mSoftKeyAction, SIGNAL(triggered()), this,
 	        SLOT(saveAndCloseEditor()));
 	// Create the data handler
 	mDataHandler = new CalenEditorDataHandler(this,mEditedEntry, mOriginalEntry);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_SHOWEDITOR_EXIT );
 }
 /*!
 	Sets up the view.
 */
 void CalenEditorPrivate::setUpView()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SETUPVIEW_ENTRY );
 	mEditorDocLoader = new CalenEditorDocLoader();
 	bool loadSuccess = false;
 	mEditorDocLoader->load(CALEN_EDITOR_XML_FILE, &loadSuccess);
 	Q_ASSERT_X(loadSuccess, "caleneditor.cpp",
 	} else {
 		window->addView(mEditorView);
 		window->setCurrentView(mEditorView);
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_SETUPVIEW_EXIT );
 }
 /*!
 	Adding the discard Menu option for the Editor view.
 */
 void CalenEditorPrivate::addDiscardAction()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ADDDISCARDACTION_ENTRY );
 	if (!mMenuItemAdded) {
 		// Set this specific menu
 		HbMenu *menu = mEditorView->menu();
 		HbAction *discardAction =
 					new HbAction(hbTrId("txt_calendar_opt_discard_changes"));
 		connect(discardAction, SIGNAL(triggered()), this,
 					SLOT(discardChanges()));
 		mEditorView->setMenu(menu);
 		mMenuItemAdded = true;
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ADDDISCARDACTION_EXIT );
 }
 /*!
 	Initialises the Model & sets for the CalenEditorForm.
 */
 void CalenEditorPrivate::initModel()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_INITMODEL_ENTRY );
 	// Remove the model.
 	if (mCalenEditorForm->model()) {
 		delete mCalenEditorForm->model();
 		mCalenEditorForm->setModel(0);
 	}
 	// Add the repeat information only if particular occurence is not being
 	if (mEditRange == ThisAndAll) {
 		addRepeatItem();
 	}
 	mCalenEditorForm->setModel(mCalenEditorModel);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_INITMODEL_EXIT );
 }
 /*!
 	Appends the Subject Item to the Data form Model.
 */
 void CalenEditorPrivate::addSubjectItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ADDSUBJECTITEM_ENTRY );
 	// Creats and appends data form model item to set subject of entry.
 	mSubjectItem = mCalenEditorModel->appendDataFormItem(
 										HbDataFormModelItem::TextItem,
 										hbTrId(
 										"txt_calendar_formlabel_val_subject"),
 										mCalenEditorModel->invisibleRootItem());
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ADDSUBJECTITEM_EXIT );
 }
 /*!
 	Appends the allday item to the Data form Model.
 */
 void CalenEditorPrivate::addAllDayCheckBoxItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ADDALLDAYCHECKBOXITEM_ENTRY );
 	mAllDayCheckBoxItem = new HbDataFormModelItem();
 	mAllDayCheckBoxItem->setType(HbDataFormModelItem::CheckBoxItem);
 	mCalenEditorModel->appendDataFormItem(mAllDayCheckBoxItem);
 	mIsAllDayItemAdded = true;
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ADDALLDAYCHECKBOXITEM_EXIT );
 }
 /*!
 	Appends the start time of the event item to the Data form Model.
 */
 void CalenEditorPrivate::addCustomItemFrom()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ADDCUSTOMITEMFROM_ENTRY );
 	HbDataFormModelItem::DataItemType itemType =
 	        static_cast<HbDataFormModelItem::DataItemType> (CustomWidgetFrom);
 	HbDataFormModelItem *customModelItem = new HbDataFormModelItem(itemType,
 								hbTrId("txt_calendar_setlabel_start_time"));
 	mCalenEditorModel->appendDataFormItem(customModelItem);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ADDCUSTOMITEMFROM_EXIT );
 }
 /*!
 	Appends the end time of the event item to the Data form Model.
 */
 void CalenEditorPrivate::addCustomItemTo()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ADDCUSTOMITEMTO_ENTRY );
 	HbDataFormModelItem::DataItemType itemType =
 	        static_cast<HbDataFormModelItem::DataItemType> (CustomWidgetTo);
 	HbDataFormModelItem *customModelItem = new HbDataFormModelItem(itemType,
 									hbTrId("txt_calendar_setlabel_end_time"));
 	mCalenEditorModel->appendDataFormItem(customModelItem);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ADDCUSTOMITEMTO_EXIT );
 }
 /*!
 	Appends the Location Item to the Data form Model.
 */
 /*!
 	Appends the custom Location widget to the Data form Model.
 */
 void CalenEditorPrivate::addCustomItemLocation()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ADDCUSTOMITEMLOCATION_ENTRY );
 	HbDataFormModelItem::DataItemType
 itemType =
 static_cast<HbDataFormModelItem::DataItemType> (CustomWidgetLocation);
 HbDataFormModelItem *customModelItem = new HbDataFormModelItem(itemType, hbTrId("txt_calendar_formlabel_val_location"));
 mCalenEditorModel->appendDataFormItem(customModelItem);
+OstTraceFunctionExit0( CALENEDITORPRIVATE_ADDCUSTOMITEMLOCATION_EXIT );
 }
 /*!
 	Appends the repeat item to the Data form Model.
 */
 void CalenEditorPrivate::addRepeatItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ADDREPEATITEM_ENTRY );
 	// Create the editor reminder field class to handle reminder related
 	// features
 	mRepeatField = new CalenEditorRepeatField(this, mCalenEditorForm,
 												  mCalenEditorModel, this);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ADDREPEATITEM_EXIT );
 }
 /*!
 Appends the reminder item to the Data form Model.
 */
 void CalenEditorPrivate::addReminderItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ADDREMINDERITEM_ENTRY );
 	// Create the editor reminder field class to handle reminder related
 	// features
 	mReminderField = new CalenEditorReminderField(this, mCalenEditorForm,
 	                                              mCalenEditorModel, this);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ADDREMINDERITEM_EXIT );
 }
 /*!
 	Appends the description item to the Data form Model.
 */
 void CalenEditorPrivate::handleDescriptionAction()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLEDESCRIPTIONACTION_ENTRY );
 	if (!mDescriptionItemAdded) {
 		populateDescriptionItem();
 		mDescriptionAction->setText(
 							hbTrId("txt_calendar_opt_remove_description"));
 	} else {
 		removeDescriptionItem();
 		mDescriptionAction->setText(
 							hbTrId("txt_calendar_opt_add_description"));
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLEDESCRIPTIONACTION_EXIT );
 }
 /*!
 	Poplulates the Model.
 */
 void CalenEditorPrivate::populateModel()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_POPULATEMODEL_ENTRY );
 	populateSubjectItem();
 	if (mIsAllDayItemAdded) {
 		populateAllDayItem();
 	}
 	}
 	if (mDescriptionItemAdded) {
 		populateDescriptionItem();
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_POPULATEMODEL_EXIT );
 }
 /*!
 	Populates the Subject Item in the Data From Model.
 */
 void CalenEditorPrivate::populateSubjectItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_POPULATESUBJECTITEM_ENTRY );
 	mSubjectItem->setContentWidgetData("text", mEditedEntry->summary());
 	mSubjectItem->setContentWidgetData("minRows", 2);
 	mSubjectItem->setContentWidgetData("maxRows", 4);
+	mSubjectItem->setContentWidgetData("objectName", "subjectItem");
 	mCalenEditorForm->addConnection(mSubjectItem,
 	                                SIGNAL(textChanged(const QString)), this,
 	                                SLOT(handleSubjectChange(const QString)));
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_POPULATESUBJECTITEM_EXIT );
 }
 /*!
 	Populates the all day item.
 */
 void CalenEditorPrivate::populateAllDayItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_POPULATEALLDAYITEM_ENTRY );
 	mAllDayCheckBoxItem->setContentWidgetData("text",
 									hbTrId("txt_calendar_list_all_day_event"));
 	if (AgendaEntry::TypeEvent == mEditedEntry->type()) {
 		//If All day is enabled.
 		mAllDayCheckBoxItem->setContentWidgetData("checkState", Qt::Checked);
 	}
+	mAllDayCheckBoxItem->setContentWidgetData("objectName", "allDayItem");
 	mCalenEditorForm->addConnection(mAllDayCheckBoxItem,
 	                                SIGNAL(stateChanged(int )), this,
 	                                SLOT(handleAllDayChange(int)));
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_POPULATEALLDAYITEM_EXIT );
 }
 /*!
 	Populates the start and end time of the event item.
 */
 void CalenEditorPrivate::populateCustomItemDateTime()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_POPULATECUSTOMITEMDATETIME_ENTRY );
 	// Get the index of the start time of the event item.
 	// Check if all day has been added or not
 	// and calculate the index accordingly
 	int itemIndex;
 	if (mIsAllDayItemAdded) {
 			                                  nextInstanceStartTime,
 			                                  nextInstanceEndTime);
 			// If no instances earlier then set it to 01/01/1900.
 			if (prevInstanceStartTime.isNull()) {
-				prevInstanceStartTime.setDate(QDate(1900, 01, 01));
+				prevInstanceEndTime.setDate(QDate(1900, 01, 01));
-				prevInstanceStartTime.setTime(QTime(0, 0, 0));
+				prevInstanceEndTime.setTime(QTime(0, 0, 0));
+			} else {
+				prevInstanceEndTime = prevInstanceEndTime.addDays(1);
 			}
 			// If no instances later then set it to 30/01/2100.
 			if (nextInstanceEndTime.isNull()) {
-				nextInstanceEndTime.setDate(QDate(2100, 12, 30));
+				nextInstanceStartTime.setDate(QDate(2100, 12, 30));
-				nextInstanceEndTime.setTime(QTime(0, 0, 0));
+				nextInstanceStartTime.setTime(QTime(0, 0, 0));
+			} else {
+				nextInstanceStartTime = nextInstanceStartTime.addDays(-1);
 			}
 			mViewFromItem->setDateRange(
-									prevInstanceStartTime.addDays(1).date(),
+									prevInstanceEndTime.date(),
-									nextInstanceStartTime.addDays(-1).date());
+									nextInstanceStartTime.date());
-			mViewToItem->setDateRange(prevInstanceEndTime.date().addDays(1),
+			mViewToItem->setDateRange(prevInstanceEndTime.date(),
-			                        nextInstanceEndTime.date().addDays(-1));
+									nextInstanceStartTime.date());
 			// If repeating daily then disable the date fields as
 			// date cannot be changed
 			if ((prevInstanceEndTime.date().daysTo(
 				mEditedEntry->startTime().date()) == 1) &&
 		// If the all day option is checked, we need to
 		// disable the time fields
 		enableFromTotimeFileds(false, mEditedEntry->startTime(),
 actualEndTime);
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_POPULATECUSTOMITEMDATETIME_EXIT );
 }
 /*!
 	Populate location item from the editor model and set it in the widget and listen
 	text change happend in the widget.
 */
 void CalenEditorPrivate::populateCustomItemLocation()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_POPULATECUSTOMITEMLOCATION_ENTRY );
 	//Get the index of the custom location  widget item of the event item.
 	// Check if all day has been added or not
 	// and calculate the index accordingly
 	int itemIndex;
 	if (mIsAllDayItemAdded) {
 	else {
 		itemIndex = LocationItem - 1;
 	}
 	QModelIndex index = mCalenEditorModel->index(itemIndex, 0);
 	mViewLocationItem = qobject_cast<CalenEditorCustomItem *>
-	                      (mCalenEditorForm->itemByIndex(index));
+									(mCalenEditorForm->itemByIndex(index));
+	mViewLocationItem->populateLocation(mEditedEntry->location());
+	// Connect the slots only after setting the location text
 	connect(mViewLocationItem, SIGNAL(locationTextChanged(const QString)),
 			this, SLOT(handleLocationChange(const QString)));
-	connect(mViewLocationItem, SIGNAL(locationTextChanged(const QString, const double, const double)),
+	connect(mViewLocationItem,
-			this, SLOT(handleLocationChange(const QString, const double, const double)));
+		SIGNAL(locationTextChanged(const QString, const double, const double)),
+		this,
-	mViewLocationItem->populateLocation(mEditedEntry->location());
+		SLOT(handleLocationChange(const QString, const double, const double)));
+	connect(mViewLocationItem, SIGNAL(locationEditingFinished()),
+				this, SLOT(handleLocationEditingFinished()));
-connect(mViewLocationItem, SIGNAL(locationEditingFinished()),
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_POPULATECUSTOMITEMLOCATION_EXIT );
-this, SLOT(handleLocationEditingFinished()));
 }
 /*!
 	Save the changed start time of the event.
 */
 void CalenEditorPrivate::saveFromDateTime(QDateTime& fromDateTime)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SAVEFROMDATETIME_ENTRY );
 	QDateTime endTime = mEditedEntry->endTime();
 	// Update the end time accordingly on UI - duration will be 60 mins
 	// bydefault only while creating new entry and if it crossed the endtime
 	if (mNewEntry && fromDateTime > endTime) {
 		endTime = fromDateTime.addSecs(3600);
 		// update the repeat choices depending on the meeting duration
 		mRepeatField->updateRepeatChoices();
 	}
 	updateReminderChoices();
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_SAVEFROMDATETIME_EXIT );
 }
 void CalenEditorPrivate::updateReminderChoices()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_UPDATEREMINDERCHOICES_ENTRY );
 	QDate referenceDate;
 	// Start date or repeat until date will be the reference to decide
 	// whether the event is in past or future.
 	if (mRepeatField && mRepeatField->isRepeatUntilItemAdded()) {
 			if (!mReminderField->isReminderFieldEnabled()) {
 				mReminderField->setReminderChoices();
 			}
 		}
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_UPDATEREMINDERCHOICES_EXIT );
 }
 /*!
 	Save the changed end time of the event.
 */
 void CalenEditorPrivate::saveToDateTime(QDateTime& toDateTime)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SAVETODATETIME_ENTRY );
 	QDateTime startTime = mEditedEntry->startTime();
 	bool fromDateChanged = false;
 	// Update the start time accordingly on UI - duration will be 60 mins
 	// bydefault for new entry and if it crosses the starttime
 	if (mNewEntry && toDateTime < startTime) {
 	// Update reminder choices if start time got changed.
 	if (fromDateChanged) {
 		updateReminderChoices();
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_SAVETODATETIME_EXIT );
 }
 /*!
 	Populates the repeat item.
 */
 void CalenEditorPrivate::populateRepeatItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_POPULATEREPEATITEM_ENTRY );
 	// Check if all day has been added or not
 	// and calculate the index accordingly
 	// all day added implies reminder time field is also added
 	int index;
 	if (mIsAllDayItemAdded && !isReminderTimeForAllDayAdded()) {
 	} else {
 		index = RepeatItem - 2;
 	}
 	mRepeatField->populateRepeatItem(index);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_POPULATEREPEATITEM_EXIT );
 }
 /*!
 	Populates the description item.
 */
 void CalenEditorPrivate::populateDescriptionItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_POPULATEDESCRIPTIONITEM_ENTRY );
 	QModelIndex repeatIndex;
 	if (mEditRange == ThisOnly) {
 		repeatIndex = mReminderField->modelIndex();
 	} else {
 		repeatIndex = mRepeatField->modelIndex();
 									"txt_calendar_formlabel_val_description")),
 									mCalenEditorModel->invisibleRootItem());
 	mDescriptionItem->setContentWidgetData("text", mEditedEntry->description());
 	mDescriptionItem->setContentWidgetData("minRows", 2);
 	mDescriptionItem->setContentWidgetData("maxRows", 4);
+	mDescriptionItem->setContentWidgetData("objectName", "descriptionItem");
 	mCalenEditorForm->addConnection(
 								mDescriptionItem,
 								SIGNAL(textChanged(const QString)), this,
 								SLOT(handleDescriptionChange(const QString)));
 	mDescriptionItemAdded = true;
-	// TODO: Scroll the previous form item to the top so that the description
+//Scroll to the description item added.
-	// field automatically scrolls to the top as well
+	mCalenEditorForm->scrollTo(mCalenEditorModel->index(descIndex, 0), HbAbstractItemView::EnsureVisible);
-	// mCalenEditorForm->scrollTo(repeatIndex, HbAbstractItemView::EnsureVisible);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_POPULATEDESCRIPTIONITEM_EXIT );
 }
 /*!
 	Removes the description item.
 */
 void CalenEditorPrivate::removeDescriptionItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_REMOVEDESCRIPTIONITEM_ENTRY );
 	// Disconnect the slot connected to description item
 	mCalenEditorForm->removeConnection(
 								   mDescriptionItem,
 								   SIGNAL(textChanged(const QString)), this,
 								   SLOT(handleDescriptionChange(const QString)));
 	// Remove the description from the entry
 	mEditedEntry->setDescription("");
 	mDescriptionItem = NULL;
 	mDescriptionItemAdded = false;
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_REMOVEDESCRIPTIONITEM_EXIT );
 }
 /*!
 	Close the Editor.
 */
 void CalenEditorPrivate::closeEditor()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_CLOSEEDITOR_ENTRY );
 	HbMainWindow* window = hbInstance->allMainWindows().first();
 	window->removeView(mEditorView);
 	emit q_ptr->dialogClosed();
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_CLOSEEDITOR_EXIT );
 }
 /*!
 	Triggered when the subject editor is being edited.
 	\param subject Contains the string displayed in the subject item.
 Triggered when the Allday Checkbox is being edited.
 \param state of checkbox.
 */
 void CalenEditorPrivate::handleAllDayChange(int state)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLEALLDAYCHANGE_ENTRY );
 	Q_UNUSED(state)
 	if (mAllDayCheckBoxItem->contentWidgetData("checkState") == Qt::Checked) {
 		// AllDayCheckBox is checked
 		// Set From/To times buttons Read-Only
 		// Display Start/End times as beginning of the day
 	}
 	if(!mNewEntry){
 		addDiscardAction();
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLEALLDAYCHANGE_EXIT );
 }
 /*!
 	Triggered when the location editor is being edited.
 	\param subject Contains the string displayed in the subject item.
 */
 void CalenEditorPrivate::handleLocationChange(const QString location)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLELOCATIONCHANGE_ENTRY );
 	mEditedEntry->setLocation(location);
 	if(!mNewEntry){
 		addDiscardAction();
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLELOCATIONCHANGE_EXIT );
 }
 /*!
 	Triggered when the location editor is being edited.
 	\param subject Contains the string displayed in the subject item.
 */
 void CalenEditorPrivate::handleLocationChange(const QString location,
 const double /*geoLatitude*/, const double /*geoLongitude*/)
 {
+	OstTraceFunctionEntry0( DUP1_CALENEDITORPRIVATE_HANDLELOCATIONCHANGE_ENTRY );
 	mEditedEntry->setLocation(location);
 	mEditedEntry->clearGeoValue();
 	addDiscardAction();
+	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_HANDLELOCATIONCHANGE_EXIT );
 }
 /*!
 * Handles the completion of location editing
 */
 void CalenEditorPrivate::handleLocationEditingFinished()
 {
+OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLELOCATIONEDITINGFINISHED_ENTRY );
 if ( !mOriginalEntry->location().isEmpty() )
 {
 AgendaGeoValue entryGeoValue =mAgendaUtil->fetchById(mEditedEntry->id()).geoValue();
 if ( !entryGeoValue.isNull() && (mEditedEntry->location()!=mOriginalEntry->location()) )
 {
 confirmationQuery->addAction(new HbAction("Yes"));
 confirmationQuery->addAction(new HbAction("No"));
 confirmationQuery->open(this, SLOT(selectEditingFinishedAction(HbAction*)));
 }
 }
+OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLELOCATIONEDITINGFINISHED_EXIT );
 }
 /*!
 * Handles the editing finished action.
 */
 void CalenEditorPrivate::selectEditingFinishedAction(HbAction* action)
 {
+OstTraceFunctionEntry0( CALENEDITORPRIVATE_SELECTEDITINGFINISHEDACTION_ENTRY );
 HbMessageBox* dlg = static_cast<HbMessageBox*>(sender());
 if (action == dlg->actions().at(1))
 {
 mEditedEntry->clearGeoValue();
 }
+OstTraceFunctionExit0( CALENEDITORPRIVATE_SELECTEDITINGFINISHEDACTION_EXIT );
 }
 /*!
 	Triggered when the description editor is being edited.
 	\param description Contains the string displayed in the description item.
 */
 void CalenEditorPrivate::handleDescriptionChange(const QString description)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLEDESCRIPTIONCHANGE_ENTRY );
 	mEditedEntry->setDescription(description);
 	if(!mNewEntry){
 		addDiscardAction();
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLEDESCRIPTIONCHANGE_EXIT );
 }
 /*!
 	Saves the entry & closes the editor.
 	If mLaunchCalendar is true, then it tries to launch the calendar
 */
 void CalenEditorPrivate::saveAndCloseEditor()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SAVEANDCLOSEEDITOR_ENTRY );
 	Action action = handleDone();
 	if (CalenEditorPrivate::ActionDelete != action) {
 		closeEditor();
 	}
 			// connect to the error signal
 			connect(launcher, SIGNAL(calendarLaunchFailed(int)), this,
 									SLOT(handleCalendarLaunchError(int)));
 		}
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_SAVEANDCLOSEEDITOR_EXIT );
 }
 /*!
 	Slot to handle errors while launching the calendar application
 */
 void CalenEditorPrivate::handleCalendarLaunchError(int error)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLECALENDARLAUNCHERROR_ENTRY );
 	// emit signal to the editor launcher
 	emit q_ptr->calendarLaunchFailed(error);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLECALENDARLAUNCHERROR_EXIT );
 }
 /*!
 	Deletes the entry.
 */
 void CalenEditorPrivate::handleDeleteAction()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLEDELETEACTION_ENTRY );
 	// If its a new entry just close the editor
 	if (mNewEntry) {
 		closeEditor();
+		OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLEDELETEACTION_EXIT );
 		return;
 	}else {
 		// Delete entry and close editor
 		deleteEntry(true);
 	}
+	OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_HANDLEDELETEACTION_EXIT );
 }
 /*!
 	Launches the Settings view.
 */
 void CalenEditorPrivate::launchSettingsView()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_LAUNCHSETTINGSVIEW_ENTRY );
 	// TODO :: Not yet implemented.
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_LAUNCHSETTINGSVIEW_EXIT );
 }
 /*!
 	Discards the changes done to the entry.
 */
 void CalenEditorPrivate::discardChanges()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_DISCARDCHANGES_ENTRY );
 	// Close the editor without saving the changes.
 	closeEditor();
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_DISCARDCHANGES_EXIT );
 }
 /*!
 * Show delete confirmation query
 */
 void CalenEditorPrivate::showDeleteConfirmationQuery(bool closeEditor)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SHOWDELETECONFIRMATIONQUERY_ENTRY );
 	HbMessageBox *popup = new HbMessageBox(HbMessageBox::MessageTypeQuestion);
 	popup->setDismissPolicy(HbDialog::NoDismiss);
 	popup->setTimeout(HbDialog::NoTimeout);
 	popup->setAttribute( Qt::WA_DeleteOnClose, true );
 QList<QAction*> list = popup->actions();
 for(int i=0; i < list.count(); i++)
 {
 popup->removeAction(list[i]);
 }
-	HbAction *deleteAction = new HbAction(hbTrId("txt_calendar_button_delete"),
+	HbAction *deleteAction = new HbAction(hbTrId("txt_calendar_button_dialog_delete"),
 										popup);
 	popup->addAction(deleteAction);
 	connect(deleteAction, SIGNAL(triggered()), this,
 										SLOT(handleDeleteAction()));
-	HbAction *cancelAction = new HbAction(hbTrId("txt_calendar_button_cancel"),
+	HbAction *cancelAction = new HbAction(hbTrId("txt_common_button_cancel"),
 											popup);
 	// Editor should not be closed for all the cases when cancel is pressed
 	if(closeEditor) {
 		connect(cancelAction, SIGNAL(triggered()), this,
 											SLOT(closeEditor()));
 	}
 	popup->addAction(cancelAction);
 	popup->open();
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_SHOWDELETECONFIRMATIONQUERY_EXIT );
 }
 /*!
 	Returns true if the entry is a child ,else false.
 	\return true if the entry is a child, false otherwise.
 */
 bool CalenEditorPrivate::isChild() const
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ISCHILD_ENTRY );
 	return mEditedEntry->recurrenceId().toUTC().isNull();
 }
 /*!
 	Check for errors in the form. This function should only be called when the
 	\return true to inform whether editor should be closed or not,
 	false otherwise
 */
 CalenEditorPrivate::Action CalenEditorPrivate::handleDone()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLEDONE_ENTRY );
 	if (mEditRange == ThisAndAll) {
 		mRepeatField->saveRepeatRule();
 	}
 	// TODO: Need to check entry status here. EntryStillExistsL
 	switch (mDataHandler->shouldSaveOrDeleteOrDoNothing(mLaunchCalendar)) {
 		case CalenEditorPrivate::ActionSave:
 			if (saveEntry()) {
+				OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLEDONE_EXIT );
 				return CalenEditorPrivate::ActionSave;
 			}
+			OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_HANDLEDONE_EXIT );
 			return CalenEditorPrivate::ActionNothing;
 		case CalenEditorPrivate::ActionDelete:
 			showDeleteConfirmationQuery(true);
+			OstTraceFunctionExit0( DUP2_CALENEDITORPRIVATE_HANDLEDONE_EXIT );
 			return CalenEditorPrivate::ActionDelete;
 		case CalenEditorPrivate::ActionNothing:
 			return CalenEditorPrivate::ActionNothing;
 		default:
 			break;
 	}
+	OstTraceFunctionExit0( DUP3_CALENEDITORPRIVATE_HANDLEDONE_EXIT );
 	return CalenEditorPrivate::ActionNothing;
 }
 /*!
 	Save the entry
 	\return true if entry is saved ,false otherwise
 */
 bool CalenEditorPrivate::saveEntry()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SAVEENTRY_ENTRY );
 	// check if we are editing child
 	if (mIsChild && (mEditRange == ThisOnly)) {
 		// Add the entry
 		mAgendaUtil->updateEntry(*mEditedEntry, true);
 		// TODO: Add the text id once available
 			HbNotificationDialog::launchDialog(hbTrId("Meeting updated"));
 		}else if(mEditedEntry->type() == AgendaEntry::TypeEvent) {
 			HbNotificationDialog::launchDialog(hbTrId("All day event updated"));
 		}
 		emit q_ptr->entrySaved();
+		OstTraceFunctionExit0( CALENEDITORPRIVATE_SAVEENTRY_EXIT );
 		return true;
 	} else if ((mEditRange == ThisOnly)) {
 		// If we are editing only this occurence, then
 		// clear the repeating properties of it
 		mAgendaUtil->clearRepeatingProperties(*mEditedEntry);
 			}
 		}
 		emit q_ptr->entrySaved();
 	} else if (error) {
 		mDataHandler->displayErrorMsg(error);
+		OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_SAVEENTRY_EXIT );
 		return false;
 	}
+	OstTraceFunctionExit0( DUP2_CALENEDITORPRIVATE_SAVEENTRY_EXIT );
 	return true;
 }
 /*!
 	Delete the entry
 	@param closeEditor set true to close editor else default value is false
 */
 void CalenEditorPrivate::deleteEntry(bool close)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_DELETEENTRY_ENTRY );
 	// if editor is launched from Notes then don't delete entry
 	// Just exit from calendar editor
 	if (mOriginalEntry->id() > 0) {
 		// If user is editing single instanc then delete single instance
 		// else delete entry
 		if (close) {
 			closeEditor();
 		}
 	}
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_DELETEENTRY_EXIT );
 }
 /*!
 Change the entry before saving, depending on AllDay checkbox state
 */
 bool CalenEditorPrivate::handleAllDayToSave()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_HANDLEALLDAYTOSAVE_ENTRY );
 	if (!mIsAllDayItemAdded) {
 		// All day item was not added, return true
+		OstTraceFunctionExit0( CALENEDITORPRIVATE_HANDLEALLDAYTOSAVE_EXIT );
 		return false;
 	}
 	// Check the state of AllDay checkBox
 	// If Creating new Entry and AllDay Box is checked.
 	if (mNewEntry && (mAllDayCheckBoxItem->contentWidgetData("checkState")
 	        == Qt::Checked)) {
 		// changes Start/End times of entry to Beginning ot the day
 		mEditedEntry->setStartAndEndTime(tempSartTime, tempEndTime);
 		mEditedEntry->setType(AgendaEntry::TypeEvent);
+		OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_HANDLEALLDAYTOSAVE_EXIT );
 		return false;
 	} else if ((mAllDayCheckBoxItem->contentWidgetData("checkState")
 	        == Qt::Checked) && (mEditedEntry->type() !=
 								AgendaEntry::TypeEvent)) {
 		// Editing existing Meetingentry, and Alldat Box is Checked
 		// Clone the entry to AllDayEntry, Delete old entry from Database
 		mAgendaUtil->cloneEntry(*mEditedEntry, AgendaEntry::TypeEvent);
 		// For later reference for the notification popup
 		mEditedEntry->setType(AgendaEntry::TypeEvent);
+		OstTraceFunctionExit0( DUP2_CALENEDITORPRIVATE_HANDLEALLDAYTOSAVE_EXIT );
 		return true;
 	} else if (mAllDayCheckBoxItem->contentWidgetData("checkState")
 	        != Qt::Checked) {
 if (mEditedEntry->type() != AgendaEntry::TypeAppoinment) {
 	            // Editing existing AllDayentry, and Alldat Box is Not-Checked
 	            // Clone the entry to MeetingEntry, Delete old entry from Database
 	            mAgendaUtil->cloneEntry(*mEditedEntry, AgendaEntry::TypeAppoinment);
 	            // For later reference for the notification popup
 	            mEditedEntry->setType(AgendaEntry::TypeAppoinment);
+	            OstTraceFunctionExit0( DUP3_CALENEDITORPRIVATE_HANDLEALLDAYTOSAVE_EXIT );
 	            return true;
 	        }
 // Check if the duration of the meeting is matching the all-day criteria
 // if yes, then we need to store it as all-day instead of normal meeting
 else if (mEditedEntry->startTime() == CalenDateUtils::beginningOfDay(mEditedEntry->startTime())) {
 mEditedEntry->setType(AgendaEntry::TypeEvent);
 // Check if this was an all-day earlier and now user has changed it like that
 // or it is a new entry
 if (mOriginalEntry->type() == AgendaEntry::TypeEvent ||
 mNewEntry) {
+OstTraceFunctionExit0( DUP4_CALENEDITORPRIVATE_HANDLEALLDAYTOSAVE_EXIT );
 return false;
 } else {
 // It was a meeting
 // Clone the entry to AllDayEntry, Delete old entry from Database
 mEditedEntry->setStartAndEndTime(tempSartTime, tempEndTime);
 mAgendaUtil->cloneEntry(*mEditedEntry, AgendaEntry::TypeEvent);
 // For later reference for the notification popup
 mEditedEntry->setType(AgendaEntry::TypeEvent);
+OstTraceFunctionExit0( DUP5_CALENEDITORPRIVATE_HANDLEALLDAYTOSAVE_EXIT );
 return true;
 }
 }
 }
 	}
+	OstTraceFunctionExit0( DUP6_CALENEDITORPRIVATE_HANDLEALLDAYTOSAVE_EXIT );
 	return false;
 }
 /*!
 Enable/Disable TimeFields depending on AllDay checkbox state
 */
 void CalenEditorPrivate::enableFromTotimeFileds(bool enableFileds,
 QDateTime fromTime,
 QDateTime toTime)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ENABLEFROMTOTIMEFILEDS_ENTRY );
 	mViewFromItem->enableFromTimeFieldAndSetTime(enableFileds, fromTime);
 	mViewToItem->enableToTimeFieldAndSetTime(enableFileds, toTime);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ENABLEFROMTOTIMEFILEDS_EXIT );
 }
 /*!
 Returns pointer of entyr being edited
 */
 AgendaEntry* CalenEditorPrivate::editedEntry()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_EDITEDENTRY_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_EDITEDENTRY_EXIT );
 	return mEditedEntry;
 }
 /*!
 Returns the pointer of original entry
 */
 AgendaEntry* CalenEditorPrivate::originalEntry()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ORIGINALENTRY_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ORIGINALENTRY_EXIT );
 	return mOriginalEntry;
 }
 /*!
 Returns true if new entry being created else false
 */
 bool CalenEditorPrivate::isNewEntry()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ISNEWENTRY_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ISNEWENTRY_EXIT );
 	return mNewEntry;
 }
 /*!
 Returns the pointer of all day check box item
 */
 HbDataFormModelItem* CalenEditorPrivate::allDayCheckBoxItem()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ALLDAYCHECKBOXITEM_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ALLDAYCHECKBOXITEM_EXIT );
 	return mAllDayCheckBoxItem;
 }
 /*!
 	Checks if all day item is added and if selected implies reminder time is added.
 	the all day item is not shown.
 	Used to calculate the index of other items which are dependant on this.
 */
 bool CalenEditorPrivate::isReminderTimeForAllDayAdded()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ISREMINDERTIMEFORALLDAYADDED_ENTRY );
 	return mReminderField->isReminderTimeForAllDayAdded();
 }
 /*!
 	Checks if it is an all day event or not.
 */
 bool CalenEditorPrivate::isAllDayEvent()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ISALLDAYEVENT_ENTRY );
 	if (mAllDayCheckBoxItem) {
 		return (mAllDayCheckBoxItem->contentWidgetData("checkState")
 													== Qt::Checked)? true:false;
 	} else if (!mNewEntry && mEditedEntry->type() == AgendaEntry::TypeEvent) {
 		// If editing single occurence then all day item not shown but still it
 		// is an all day event..
+		OstTraceFunctionExit0( CALENEDITORPRIVATE_ISALLDAYEVENT_EXIT );
 		return true;;
 	} else {
+		OstTraceFunctionExit0( DUP1_CALENEDITORPRIVATE_ISALLDAYEVENT_EXIT );
 		return false;
 	}
 }
 /*!
 	Returns the current index of the reminder field.
 */
 int CalenEditorPrivate::currentIndexOfReminderField()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_CURRENTINDEXOFREMINDERFIELD_ENTRY );
 	return mReminderField->currentReminderIndex();
 }
 /*!
 	Sets the index.
 	/param index indicates the index value to be set.
 */
 void CalenEditorPrivate::setCurrentIndexOfReminderField(int index)
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_SETCURRENTINDEXOFREMINDERFIELD_ENTRY );
 	mReminderField->setCurrentIndex(index);
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_SETCURRENTINDEXOFREMINDERFIELD_EXIT );
 }
 /*!
 	Sets the reminder choices for a non all day event.
 */
 void CalenEditorPrivate::setReminderChoices()
 {
-		mReminderField->setReminderChoices();
+OstTraceFunctionEntry0( CALENEDITORPRIVATE_SETREMINDERCHOICES_ENTRY );
+mReminderField->setReminderChoices();
+OstTraceFunctionExit0( CALENEDITORPRIVATE_SETREMINDERCHOICES_EXIT );
 }
 /*!
 	Checks if editing all occurences or a single occurence.
 */
 bool CalenEditorPrivate::isEditRangeThisOnly()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ISEDITRANGETHISONLY_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ISEDITRANGETHISONLY_EXIT );
 	return (mEditRange == ThisOnly);
 }
 /*!
 	Checks if all day field is added.
 */
 bool CalenEditorPrivate::isAllDayFieldAdded()
 {
+	OstTraceFunctionEntry0( CALENEDITORPRIVATE_ISALLDAYFIELDADDED_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORPRIVATE_ISALLDAYFIELDADDED_EXIT );
 	return mIsAllDayItemAdded;
 }
 // End of file	--Don't remove this.

changeset 51	0b38fc5b94c6
parent 45	b6db4fd4947b
child 55	2c54b51f39c4