--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/calendarui/caleneditor/src/caleneditordatahandler.cpp Mon May 03 12:30:32 2010 +0300
@@ -0,0 +1,539 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+* Definition of CalenEditorDataHandler class.
+*
+*/
+
+// System Includes
+#include <hbmessagebox.h>
+#include <hbdataformmodelitem.h>
+
+// User Includes
+#include "caleneditordatahandler.h"
+#include "calendateutils.h"
+#include "agendaentry.h"
+
+/*!
+ \class CalenEditorDataHandler
+ */
+/*!
+ Constructor.
+ */
+
+CalenEditorDataHandler::CalenEditorDataHandler(CalenEditorPrivate* calenEditor,
+ AgendaEntry* editedEntry,
+ AgendaEntry* originalEntry)
+: mCalenEditor(calenEditor),mEditedEntry(editedEntry), mOriginalEntry(originalEntry)
+{
+
+}
+
+/*!
+ Destructor
+ */
+CalenEditorDataHandler::~CalenEditorDataHandler()
+{
+ // Nothing Yet
+}
+
+/*!
+ Returns pointer for edited entry
+ \return pointer for edited entry
+ */
+AgendaEntry* CalenEditorDataHandler::editedEntry()
+{
+ return mEditedEntry;
+}
+
+/*!
+ Returns pointer for original entry
+ \return pointer for original entry
+ */
+AgendaEntry* CalenEditorDataHandler::originalEntry()
+{
+ return mOriginalEntry;
+}
+
+/*!
+ Checks if user entered data violates the permitted attributes
+ \return Error Error indicating the violated parameter
+ */
+CalenEditorPrivate::Error CalenEditorDataHandler::checkErrorsForThisAndAll()
+{
+ //TODO : Remove implementation once handle all repeating errors
+ const QDateTime startTime = mEditedEntry->startTime();
+ const QDateTime endTime = mEditedEntry->endTime();
+
+ // Repeating entry checks:
+ if (mEditedEntry->isRepeating()) {
+ // Check that repeat until date is a) later than start date
+ // (for new notes)
+ // b) not before start date
+ // (for existing notes)
+ QDateTime repeatUntilDay = mEditedEntry->repeatRule().until();
+
+ QDateTime repeatStartDay;
+
+ // if new note or old note isnt repeating
+ // edited.repeatUntil date must be greater than edited.start date
+ // else
+ // if IsRepeatRuleEdited or IsStartDateTimeEdited
+ // (either one above will make a new rule in which edited.startdate
+ // is the start date)
+ // edited.repeatUntil must be greater than edited.start date
+ // else
+ // edited.repeatUntil must be greater than start date on disk
+
+ if (mCalenEditor->isNewEntry() || mOriginalEntry->repeatRule().isNull()
+ || isRepeatRuleEdited() || isStartDateTimeEdited()) {
+ // We don't have an rrule so we can't get the rrule start date,
+ // or user has edited a field that will cause new start date to be
+ // used in the new rule.
+ // Use the edited entry's start date.
+ repeatStartDay = startTime;
+ } else {
+ // original rule is valid and new rule will not be created
+ repeatStartDay = mOriginalEntry->repeatRule().repeatRuleStart();
+ }
+
+ if (durationGreaterThanRepeatIntervalError()) {
+ return CalenEditorPrivate::
+ CalenEditorErrorDurationGreaterThanRepeatInterval;
+ }
+ return CalenEditorPrivate::CalenEditorErrorNone;
+ }
+ 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
+{
+ return (isSummaryEdited() ||
+ isAllDayEdited() ||
+ isLocationEdited() ||
+ isStartDateTimeEdited() ||
+ isEndDateTimeEdited() ||
+ isAlarmEdited() ||
+ isRepeatRuleEdited() ||
+ isDescriptionEdited());
+}
+
+/*!
+ Returns true if the summary has been edited, false otherwise.
+ \return true if the summary has been edited, false otherwise.
+ */
+bool CalenEditorDataHandler::isSummaryEdited() const
+{
+ 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
+{
+ HbDataFormModelItem* alldayItem = mCalenEditor->allDayCheckBoxItem();
+ if (alldayItem) {
+ if (mOriginalEntry->type() == AgendaEntry::TypeEvent) {
+ if (alldayItem->contentWidgetData("checkState")
+ == Qt::Checked) {
+ return false;
+ } else {
+ return true;
+ }
+ } else if (mOriginalEntry->type() == AgendaEntry::TypeAppoinment) {
+ if (alldayItem->contentWidgetData("checkState")
+ == Qt::Checked) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ }
+ 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
+{
+ 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
+{
+ 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
+{
+ 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
+{
+ 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
+{
+ if ((mOriginalEntry->repeatRule().type() == AgendaRepeatRule::InvalidRule)
+ && (mEditedEntry->repeatRule().type()
+ == AgendaRepeatRule::InvalidRule)) {
+ return false;
+ } else {
+ return ((mOriginalEntry->repeatRule().type() !=
+ mEditedEntry->repeatRule().type())
+ || (mOriginalEntry->repeatRule().until().date() !=
+ mEditedEntry->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
+{
+ 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
+{
+ return (isAllDayEdited() ||
+ isStartDateTimeEdited() ||
+ isEndDateTimeEdited() ||
+ isAlarmEdited() ||
+ isRepeatRuleEdited());
+}
+
+/*!
+ Returns true if summary && location && description text items are all empty,
+ false otherwise.
+ \return true if text items are all empty,false otherwise.
+ */
+bool CalenEditorDataHandler::areTextItemsEmpty() const
+{
+ return (mEditedEntry->summary().isEmpty()
+ && mEditedEntry->location().isEmpty()
+ && mEditedEntry->description().isEmpty());
+}
+
+/*!
+ Returns true if the user cleared the text in the location and summary items,
+ false otherwise.
+ \return true if summary & location items are cleared,false otherwise.
+ */
+bool CalenEditorDataHandler::areTextItemsCleared() const
+{
+ if (mEditedEntry->summary().isEmpty() &&
+ mEditedEntry->location().isEmpty() &&
+ mEditedEntry->description().isEmpty()) {
+ if (isSummaryEmptied()
+ || isLocationEmptied()
+ || isDescriptionEmptied()) {
+ return true;
+ }
+ }
+ 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
+{
+ return (!mOriginalEntry->summary().isEmpty()
+ && mEditedEntry->summary().isEmpty());
+}
+
+/*!
+ Returns true the location was not empty in original && is empty
+ in the edited note,false otherwise
+ \return true if location is cleared in edited note,false otherwise
+ */
+bool CalenEditorDataHandler::isLocationEmptied() const
+{
+ return (!mOriginalEntry->location().isEmpty()
+ && mEditedEntry->location().isEmpty());
+}
+
+/*!
+ Returns true the description was not empty in original && is empty
+ in the edited note,false otherwise
+ \return true if description is cleared in edited note,false otherwise
+ */
+bool CalenEditorDataHandler::isDescriptionEmptied() const
+{
+ return (!mOriginalEntry->description().isEmpty()
+ && mEditedEntry->description().isEmpty());
+}
+
+/*!
+ Works out whether the entry should be deleted, saved,
+ or whether no action should be taken.
+ \return enum Action
+ */
+CalenEditorPrivate::Action CalenEditorDataHandler::shouldSaveOrDeleteOrDoNothing(bool launchCalendar)
+ const
+{
+ // 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
+ 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()) {
+ return CalenEditorPrivate::ActionNothing;
+ } else {
+ 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
+ return CalenEditorPrivate::ActionDelete;
+ }
+ // Save the note, since the text fields contain something
+ return CalenEditorPrivate::ActionSave;
+}
+
+/*!
+ Returns true if the duration of instances of the meeting is greater than
+ the repeat period of the series, false otherwise.
+ \return true if duration of meeting is greater than repeat period, false
+ otherwise
+ */
+bool CalenEditorDataHandler::durationGreaterThanRepeatIntervalError() const
+{
+ bool isError = false;
+ switch (mEditedEntry->repeatRule().type()) {
+ case AgendaRepeatRule::DailyRule: {
+ int durationDays =
+ mEditedEntry->startTime().daysTo(mEditedEntry->endTime());
+ isError = durationDays >= 1;
+ }
+ break;
+ case AgendaRepeatRule::WeeklyRule: {
+ int durationDays =
+ mEditedEntry->startTime().daysTo(mEditedEntry->endTime());
+ if (mEditedEntry->repeatRule().interval() == 1) {
+ isError = durationDays >= 7;
+ } else {
+ isError = durationDays >= 14;
+ }
+ }
+ break;
+ case AgendaRepeatRule::MonthlyRule: {
+ if (mEditedEntry->endTime()
+ >= (mEditedEntry->startTime().addMonths(1))) {
+ isError = true;
+ }
+ }
+ break;
+ case AgendaRepeatRule::YearlyRule: {
+ if (mEditedEntry->endTime()
+ >= (mEditedEntry->startTime().addYears(1))) {
+ isError = true;
+ }
+ }
+ break;
+ default:
+ // Not repeating, no error
+ isError = false;
+ break;
+ }
+ 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
+{
+ CalenEditorPrivate::Error error = CalenEditorPrivate::CalenEditorErrorNone;
+ // If alarm not active, no check
+ if (!mEditedEntry->alarm().isNull()) {
+ int alarm = mEditedEntry->alarm().timeOffset();
+ QDateTime startTime = mEditedEntry->startTime();
+ QDateTime alarmTime;
+ if (alarm > 0) {
+ alarmTime = startTime.addSecs(-alarm * 60);
+ } else {
+ alarmTime = startTime.addSecs(alarm * 60);
+ }
+ QDateTime currentTime = CalenDateUtils::now();
+ if (isAlarmInAcceptablePeriod(error, alarmTime, startTime)) {
+ if (!series && (alarmTime < currentTime)) {
+ // dont let non-repeating future entries have alarms in past
+ error = CalenEditorPrivate::CalenEditorErrorAlarmTimePast;
+ }
+ }
+ }
+ return error;
+}
+
+/*!
+ Checks if AlarmTime is 31 days from StartTime,
+ then sets Error to CalenEditorErrorAlarmDateTooManyDaysBeforeNote and
+ returns false
+ Checks if AlarmTime is later StartTime,
+ then sets Error to CalenEditorErrorAlarmTimeLaterThanNote and returns false
+ \return true if error untouched, false otherwise
+ */
+bool CalenEditorDataHandler::isAlarmInAcceptablePeriod(CalenEditorPrivate::Error &error,
+ const QDateTime &alarmTime,
+ const QDateTime &startTime) const
+{
+ QDateTime upperLimit = startTime;
+
+ QDateTime lowerLimit = startTime.addDays(-31);
+ bool acceptable = true;
+ if (alarmTime < lowerLimit) {
+ acceptable = false;
+ error = CalenEditorPrivate::CalenEditorErrorAlarmDateTooManyDaysBeforeNote;
+ } else {
+ if (alarmTime > upperLimit) {
+ acceptable = false;
+ error = CalenEditorPrivate::CalenEditorErrorAlarmTimeLaterThanNote;
+ }
+ }
+ return acceptable;
+}
+
+/*!
+ Display the given error msg
+ \param error Error value for which message has to be displayed
+ */
+void CalenEditorDataHandler::displayErrorMsg(int error)
+{
+ QString errorMsg = QString::Null();
+
+ switch (error) {
+ case CalenEditorPrivate::CalenEditorErrorAlarmTimeLaterThanNote:
+ errorMsg.append( hbTrId(
+ "txt_calendar_dpopinfo_alarm_later_than_note"));
+ break;
+ case CalenEditorPrivate::CalenEditorErrorAlarmTimePast:
+ errorMsg.append( hbTrId(
+ "txt_calendar_dpopinfo_the_time_for_the_note_alarm"));
+ break;
+ case CalenEditorPrivate::CalenEditorErrorAlarmDateTooManyDaysBeforeNote:
+ errorMsg.append( hbTrId(
+ "txt_calendar_dpopinfo_alarm_date_is_too_past"));
+ break;
+ case CalenEditorPrivate::CalenEditorErrorRepeatUntilEarlierThanNote:
+ errorMsg.append( hbTrId(
+ "txt_calendar_dpopinfo_repeat_until_has_to_be_later"));
+ break;
+ case
+ CalenEditorPrivate::CalenEditorErrorDurationGreaterThanRepeatInterval:
+ dispalyErrorMsgByRepeatType();
+ break;
+ case CalenEditorPrivate::CalenEditorErrorStopTimeEarlierThanStartTime:
+ errorMsg.append( hbTrId(
+ "txt_calendar_dpopinfo_note_ends_before_than_starts"));
+ break;
+ default:
+ break;
+ }
+ if (!errorMsg.isNull()) {
+ HbMessageBox::information(errorMsg);
+ }
+}
+
+/*!
+ Displays error message related to repeat fields
+ */
+void CalenEditorDataHandler::dispalyErrorMsgByRepeatType()
+{
+ QString errorMsg = QString::Null();
+
+ int durationDays =
+ mEditedEntry->startTime().daysTo(mEditedEntry->endTime());
+ int numDaysEntrySpan = durationDays + 1;
+ // Add the text proper text ids
+ switch (mEditedEntry->repeatRule().type()) {
+ case AgendaRepeatRule::DailyRule:
+ errorMsg.append( hbTrId(
+ "txt_calendar_dpopinfo_l1_day_meeting_cant_daily"));
+ break;
+ case AgendaRepeatRule::WeeklyRule:
+ if (mEditedEntry->repeatRule().interval() == 1) {
+ errorMsg.append( hbTrId(
+ "txt_calendar_dpopinfo_l1_day_meeting_cant_weekly"));
+ } else {
+ errorMsg.append("meeting duration is more than 2 weeks");
+ }
+ break;
+ case AgendaRepeatRule::MonthlyRule:
+ errorMsg.append( hbTrId(
+ "txt_calendar_dpopinfo_l1_day_meeting_cant_monthly"));
+ break;
+ case AgendaRepeatRule::YearlyRule:
+ errorMsg.append( hbTrId(
+ "txt_calendar_dpopinfo_l1_day_meeting_cant_yearly"));
+ break;
+ default:
+ break;
+ }
+ if (!errorMsg.isNull()) {
+ HbMessageBox::information(errorMsg.arg(numDaysEntrySpan));
+ }
+}
+
+// End of file --Don't remove this.