FCL/sf/app/organizer: comparison calendarui/caleneditor/src/caleneditordatahandler.cpp

equal deleted inserted replaced

-:ecd7b9840282
+:0b38fc5b94c6
 // User Includes
 #include "caleneditordatahandler.h"
 #include "calendateutils.h"
 #include "agendaentry.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "caleneditordatahandlerTraces.h"
+#endif
 /*!
 	\class CalenEditorDataHandler
 */
 /*!
 CalenEditorDataHandler::CalenEditorDataHandler(CalenEditorPrivate* calenEditor,
 AgendaEntry* editedEntry,
 	                       AgendaEntry* originalEntry)
 : mCalenEditor(calenEditor),mEditedEntry(editedEntry), mOriginalEntry(originalEntry)
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_CALENEDITORDATAHANDLER_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_CALENEDITORDATAHANDLER_EXIT );
 }
 /*!
 	 Destructor
 */
 CalenEditorDataHandler::~CalenEditorDataHandler()
 {
+	OstTraceFunctionEntry0( DUP1_CALENEDITORDATAHANDLER_CALENEDITORDATAHANDLER_ENTRY );
 	// Nothing Yet
+	OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_CALENEDITORDATAHANDLER_EXIT );
 }
 /*!
 	 Returns pointer for edited entry
 	 \return pointer for edited entry
 */
 AgendaEntry* CalenEditorDataHandler::editedEntry()
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_EDITEDENTRY_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_EDITEDENTRY_EXIT );
 	return mEditedEntry;
 }
 /*!
 	 Returns pointer for original entry
 	 \return pointer for original entry
 */
 AgendaEntry* CalenEditorDataHandler::originalEntry()
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ORIGINALENTRY_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ORIGINALENTRY_EXIT );
 	return mOriginalEntry;
 }
 /*!
 	 Checks if user entered data violates the permitted attributes
 	 \return Error Error indicating the violated parameter
 */
 CalenEditorPrivate::Error CalenEditorDataHandler::checkErrorsForThisAndAll()
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_CHECKERRORSFORTHISANDALL_ENTRY );
 	//TODO :  Remove implementation once handle all repeating errors
 	const QDateTime startTime = mEditedEntry->startTime();
 	const QDateTime endTime = mEditedEntry->endTime();
 	// Repeating entry checks:
 			// original rule is valid and new rule will not be created
 			repeatStartDay = mOriginalEntry->repeatRule().repeatRuleStart();
 		}
 		if (durationGreaterThanRepeatIntervalError()) {
+			OstTraceFunctionExit0( CALENEDITORDATAHANDLER_CHECKERRORSFORTHISANDALL_EXIT );
 			return CalenEditorPrivate::
 							CalenEditorErrorDurationGreaterThanRepeatInterval;
 		}
+		OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_CHECKERRORSFORTHISANDALL_EXIT );
 		return CalenEditorPrivate::CalenEditorErrorNone;
 	}
+	OstTraceFunctionExit0( DUP2_CALENEDITORDATAHANDLER_CHECKERRORSFORTHISANDALL_EXIT );
 	return CalenEditorPrivate::CalenEditorErrorNone;
 }
 /*!
 	Returns true if the entry has been modified, false otherwise.
 	\return true if the entry has been modified, false otherwise.
 */
 bool CalenEditorDataHandler::isEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISEDITED_ENTRY );
 	return (isSummaryEdited() ||
 			isAllDayEdited() ||
 			isLocationEdited() ||
 			isStartDateTimeEdited() ||
 			isEndDateTimeEdited() ||
 	Returns true if the summary has been edited, false otherwise.
 	\return true if the summary has been edited, false otherwise.
 */
 bool CalenEditorDataHandler::isSummaryEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISSUMMARYEDITED_ENTRY );
 	return (mOriginalEntry->summary() != mEditedEntry->summary());
 }
 /*!
 	Returns true if the all day has been edited, false otherwise.
 	\return true if the all day has been edited, false otherwise.
 */
 bool CalenEditorDataHandler::isAllDayEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISALLDAYEDITED_ENTRY );
 	HbDataFormModelItem* alldayItem = mCalenEditor->allDayCheckBoxItem();
 	if (alldayItem) {
 		if (mOriginalEntry->type() == AgendaEntry::TypeEvent) {
 			if (alldayItem->contentWidgetData("checkState")
 			        == Qt::Checked) {
+				OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );
 				return false;
 			} else {
+				OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );
 				return true;
 			}
 		} else if (mOriginalEntry->type() == AgendaEntry::TypeAppoinment) {
 			if (alldayItem->contentWidgetData("checkState")
 			        == Qt::Checked) {
+				OstTraceFunctionExit0( DUP2_CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );
 				return true;
 			} else {
+				OstTraceFunctionExit0( DUP3_CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );
 				return false;
 			}
 		}
 	}
+	OstTraceFunctionExit0( DUP4_CALENEDITORDATAHANDLER_ISALLDAYEDITED_EXIT );
 	return false;
 }
 /*!
 	Returns true if the location has been edited, false otherwise.
 	\return true if the location has been edited, false otherwise.
 */
 bool CalenEditorDataHandler::isLocationEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISLOCATIONEDITED_ENTRY );
 	return (mOriginalEntry->location() != mEditedEntry->location());
 }
 /*!
 	Returns true if the start date/time has been edited, false otherwise.
 	\return true if the start date/time has been edited, false otherwise.
 */
 bool CalenEditorDataHandler::isStartDateTimeEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISSTARTDATETIMEEDITED_ENTRY );
 	return (mOriginalEntry->startTime() != mEditedEntry->startTime());
 }
 /*!
 	Returns true if the end date/time has been edited, false otherwise.
 	\return true if the end date/time has been edited, false otherwise.
 */
 bool CalenEditorDataHandler::isEndDateTimeEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISENDDATETIMEEDITED_ENTRY );
 	return (mOriginalEntry->endTime() != mEditedEntry->endTime());
 }
 /*!
 	Returns true if the alarm has been edited, false otherwise.
 	\return true if the alarm has been edited, false otherwise.
 */
 bool CalenEditorDataHandler::isAlarmEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISALARMEDITED_ENTRY );
 	return (mOriginalEntry->alarm() != mEditedEntry->alarm());
 }
 /*!
 	Returns true if the repeat rule has been edited, false otherwise.
 	\return true if the repeat rule has been edited, false otherwise.
 */
 bool CalenEditorDataHandler::isRepeatRuleEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISREPEATRULEEDITED_ENTRY );
 	if ((mOriginalEntry->repeatRule().type() == AgendaRepeatRule::InvalidRule)
 	        && (mEditedEntry->repeatRule().type()
 	                == AgendaRepeatRule::InvalidRule)) {
+		OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ISREPEATRULEEDITED_EXIT );
 		return false;
 	} else {
 		return ((mOriginalEntry->repeatRule().type() !=
 				mEditedEntry->repeatRule().type())
 				|| (mOriginalEntry->repeatRule().until().date() !=
 	Returns true if the Description field has been edited, false otherwise.
 	\return true if the Description field has been edited, false otherwise.
 */
 bool CalenEditorDataHandler::isDescriptionEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISDESCRIPTIONEDITED_ENTRY );
 	return (mOriginalEntry->description() != mEditedEntry->description());
 }
 /*!
 	Returns true if any of the non-text items (e.g. time fields) of the entry
 	have been edited, false otherwise.
 	\return true if any of the non text items edited,false otherwise.
 */
 bool CalenEditorDataHandler::nonTextItemsEdited() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_NONTEXTITEMSEDITED_ENTRY );
 	return (isAllDayEdited() ||
 			isStartDateTimeEdited() ||
 			isEndDateTimeEdited() ||
 			isAlarmEdited() ||
 			isRepeatRuleEdited());
 	false otherwise.
 	\return true if text items are all empty,false otherwise.
 */
 bool CalenEditorDataHandler::areTextItemsEmpty() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ARETEXTITEMSEMPTY_ENTRY );
 	return (mEditedEntry->summary().isEmpty()
 	        && mEditedEntry->location().isEmpty()
 	        && mEditedEntry->description().isEmpty());
 }
 	false otherwise.
 	\return true if summary & location items are cleared,false otherwise.
 */
 bool CalenEditorDataHandler::areTextItemsCleared() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ARETEXTITEMSCLEARED_ENTRY );
 	if (mEditedEntry->summary().isEmpty() &&
 			mEditedEntry->location().isEmpty() &&
 			mEditedEntry->description().isEmpty()) {
 		if (isSummaryEmptied()
 				|| isLocationEmptied()
 				|| isDescriptionEmptied()) {
+			OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ARETEXTITEMSCLEARED_EXIT );
 			return true;
 		}
 	}
+	OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_ARETEXTITEMSCLEARED_EXIT );
 	return false;
 }
 /*!
 	Returns true the summary was not empty in original && is empty
 	in the edited note,false otherwise
 	\return true if summary is cleared in edited note,false otherwise
 */
 bool CalenEditorDataHandler::isSummaryEmptied() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISSUMMARYEMPTIED_ENTRY );
 	return (!mOriginalEntry->summary().isEmpty()
 	        && mEditedEntry->summary().isEmpty());
 }
 /*!
 	in the edited note,false otherwise
 	\return true if location is cleared in edited note,false otherwise
 */
 bool CalenEditorDataHandler::isLocationEmptied() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISLOCATIONEMPTIED_ENTRY );
 	return (!mOriginalEntry->location().isEmpty()
 	        && mEditedEntry->location().isEmpty());
 }
 /*!
 	in the edited note,false otherwise
 	\return true if description is cleared in edited note,false otherwise
 */
 bool CalenEditorDataHandler::isDescriptionEmptied() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISDESCRIPTIONEMPTIED_ENTRY );
 	return (!mOriginalEntry->description().isEmpty()
 	        && mEditedEntry->description().isEmpty());
 }
 /*!
 	\return enum Action
 */
 CalenEditorPrivate::Action CalenEditorDataHandler::shouldSaveOrDeleteOrDoNothing(bool launchCalendar)
 																		const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_ENTRY );
 	// Need to save the entry if third party calls editor to launch the
 	// calendar after that. So, that entry will be new entry adn we assume
 	// that client launches editor with some prefilled text items
 	if (!isEdited() && !launchCalendar) {
 		// Not edited at all OR
 		// Only added space characters to text fields but not
 		// edited the non-text items
 		// no need to save the entry
+		OstTraceFunctionExit0( CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );
 		return CalenEditorPrivate::ActionNothing;
 	}
 	// new entry is edited
 	if (mCalenEditor->isNewEntry()) {
 		// Subject && Location && Description are text items.
 		// If text items as a whole is not empty, we can save the note
 		// If text items as a whole is empty, we can still save the note
 		// since we edited "non-text" fields
 		if (!nonTextItemsEdited() && areTextItemsEmpty()) {
+			OstTraceFunctionExit0( DUP1_CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );
 			return CalenEditorPrivate::ActionNothing;
 		} else {
+			OstTraceFunctionExit0( DUP2_CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );
 			return CalenEditorPrivate::ActionSave;
 		}
 	}
 	if (areTextItemsCleared() && !nonTextItemsEdited()) {
 		// ***** edited entry + text items emptied + non-text items not edited
 		// Even if user may have edited non-text fields,
 		// delete the note
+		OstTraceFunctionExit0( DUP3_CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );
 		return CalenEditorPrivate::ActionDelete;
 	}
 	// Save the note, since the text fields contain something
+	OstTraceFunctionExit0( DUP4_CALENEDITORDATAHANDLER_SHOULDSAVEORDELETEORDONOTHING_EXIT );
 	return CalenEditorPrivate::ActionSave;
 }
 /*!
 	Returns true if the duration of instances of the meeting is greater than
 	\return true if duration of meeting is greater than repeat period, false
 	otherwise
 */
 bool CalenEditorDataHandler::durationGreaterThanRepeatIntervalError() const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_DURATIONGREATERTHANREPEATINTERVALERROR_ENTRY );
 	bool isError = false;
 	switch (mEditedEntry->repeatRule().type()) {
 		case AgendaRepeatRule::DailyRule: {
 			int durationDays =
 			        mEditedEntry->startTime().daysTo(mEditedEntry->endTime());
 		default:
 			// Not repeating, no error
 			isError = false;
 			break;
 	}
+	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_DURATIONGREATERTHANREPEATINTERVALERROR_EXIT );
 	return isError;
 }
 /*!
 	Check the alarm fields for errors.
 	\return the error if found, or CalenEditorErrorNone if no error found.
 */
 CalenEditorPrivate::Error CalenEditorDataHandler::checkAlarmFieldsForErrors(
 															bool series) const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_CHECKALARMFIELDSFORERRORS_ENTRY );
 	CalenEditorPrivate::Error error = CalenEditorPrivate::CalenEditorErrorNone;
 	// If alarm not active, no check
 	if (!mEditedEntry->alarm().isNull()) {
 		int alarm = mEditedEntry->alarm().timeOffset();
 		QDateTime startTime = mEditedEntry->startTime();
 				// dont let non-repeating future entries have alarms in past
 				error = CalenEditorPrivate::CalenEditorErrorAlarmTimePast;
 			}
 		}
 	}
+	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_CHECKALARMFIELDSFORERRORS_EXIT );
 	return error;
 }
 /*!
 	Checks if AlarmTime is 31 days from StartTime,
 */
 bool CalenEditorDataHandler::isAlarmInAcceptablePeriod(CalenEditorPrivate::Error &error,
 										const QDateTime &alarmTime,
 										const QDateTime &startTime) const
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_ISALARMINACCEPTABLEPERIOD_ENTRY );
 	QDateTime upperLimit = startTime;
 	QDateTime lowerLimit = startTime.addDays(-31);
 	bool acceptable = true;
 	if (alarmTime < lowerLimit) {
 		if (alarmTime > upperLimit) {
 			acceptable = false;
 			error = CalenEditorPrivate::CalenEditorErrorAlarmTimeLaterThanNote;
 		}
 	}
+	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_ISALARMINACCEPTABLEPERIOD_EXIT );
 	return acceptable;
 }
 /*!
 	Display the given error msg
 	\param error Error value for which message has to be displayed
 */
 void CalenEditorDataHandler::displayErrorMsg(int error)
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_DISPLAYERRORMSG_ENTRY );
 	QString errorMsg = QString::Null();
 	switch (error) {
 		case CalenEditorPrivate::CalenEditorErrorAlarmTimeLaterThanNote:
 			errorMsg.append( hbTrId(
 			break;
 	}
 	if (!errorMsg.isNull()) {
 		HbMessageBox::information(errorMsg);
 	}
+	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_DISPLAYERRORMSG_EXIT );
 }
 /*!
 	 Displays error message related to repeat fields
 */
 void CalenEditorDataHandler::dispalyErrorMsgByRepeatType()
 {
+	OstTraceFunctionEntry0( CALENEDITORDATAHANDLER_DISPALYERRORMSGBYREPEATTYPE_ENTRY );
 	QString errorMsg = QString::Null();
 	int durationDays =
 	        mEditedEntry->startTime().daysTo(mEditedEntry->endTime());
 	int numDaysEntrySpan = durationDays + 1;
 			break;
 	}
 	if (!errorMsg.isNull()) {
 		HbMessageBox::information(errorMsg.arg(numDaysEntrySpan));
 	}
+	OstTraceFunctionExit0( CALENEDITORDATAHANDLER_DISPALYERRORMSGBYREPEATTYPE_EXIT );
 }
 // End of file	--Don't remove this.

changeset 51	0b38fc5b94c6
parent 23	fd30d51f876b
child 55	2c54b51f39c4