--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/agendainterface/agendautil/src/agendaentry.cpp Fri Apr 16 14:57:40 2010 +0300
@@ -0,0 +1,1946 @@
+/*
+* 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:
+*
+*/
+#include "agendaentry.h"
+#include "agendaentry_p.h"
+
+#include <calalarm.h>
+#include <QDateTime>
+
+/****************************************************
+ *
+ * AgendaAttendee
+ *
+ ****************************************************/
+
+/*!
+ \class AgendaAttendee
+
+ \brief Class representing an attendee of an event.
+ Contains the status and the role information of the attendee.
+ Contains information about whether or not a response was requested for this attendee.
+
+*/
+
+/*!
+ \enum AgendaAttendee::ParticipantRole
+
+ This enum defines the possible roles for a AgendaAttendee object
+ in case of entry's type is event.
+*/
+/*! \var AgendaAttendee::ParticipantRole AgendaAttendee::RequiredParticipant
+ A required participant of the event.
+*/
+/*! \var AgendaAttendee::ParticipantRole AgendaAttendee::OptionalParticipant
+ An optional participant of the event
+*/
+/*! \var AgendaAttendee::ParticipantRole AgendaAttendee::NonParticipant
+ A non-participant of the event
+*/
+/*! \var AgendaAttendee::ParticipantRole AgendaAttendee::ChairParticipant
+ This participant will chair the event
+*/
+/*! \var AgendaAttendee::ParticipantRole AgendaAttendee::ParticipantRoleUnknown
+ The role is unknown
+*/
+
+/*!
+ \enum AgendaAttendee::StatusType
+
+ This enum defines the possible statuses for a AgendaAttendee object.
+*/
+/*! \var AgendaAttendee::StatusType AgendaAttendee::StatusNeedsAction
+ Action is required by attendee
+*/
+/*! \var AgendaAttendee::StatusType AgendaAttendee::StatusAccepted
+ Attendee has accepted request
+*/
+/*! \var AgendaAttendee::StatusType AgendaAttendee::StatusTentative
+ Attendee has tentatively accepted the request
+*/
+/*! \var AgendaAttendee::StatusType AgendaAttendee::StatusConfirmed
+ Attendee's presence is confirmed
+*/
+/*! \var AgendaAttendee::StatusType AgendaAttendee::StatusDeclined
+ Attendee has declined request
+*/
+/*! \var AgendaAttendee::StatusType AgendaAttendee::StatusCompleted
+ The required action has been completed by attendee
+*/
+/*! \var AgendaAttendee::StatusType AgendaAttendee::StatusDelegated
+ Attendee has delegated the request to another person
+*/
+/*! \var AgendaAttendee::StatusType AgendaAttendee::StatusInProcess
+ A to-do action in the process of being completed
+*/
+/*! \var AgendaAttendee::StatusType AgendaAttendee::StatusUnknown
+ The status is unknown
+*/
+
+/*!
+ Creates an attendee.
+*/
+AgendaAttendee::AgendaAttendee()
+ : d(NULL)
+{
+}
+
+/*!
+ Constructs a new attendee using given \a address.
+
+ \param address The address of the attendee
+*/
+AgendaAttendee::AgendaAttendee(const QString& address)
+ : d(new AgendaAttendeePrivate)
+{
+ d->m_address = address;
+ d->ref.ref();
+}
+
+/*!
+ Destroys the attendee.
+*/
+AgendaAttendee::~AgendaAttendee()
+{
+ if (d && !d->ref.deref())
+ {
+ delete d;
+ }
+}
+
+/*!
+ Creates a copy of a given attendee.
+
+ \param other attendee to be copied.
+*/
+AgendaAttendee::AgendaAttendee(const AgendaAttendee& other)
+ : d(other.d)
+{
+ if (d) {
+ d->ref.ref();
+ }
+}
+
+/*!
+ Sets the email address of the attendee.
+
+ \param address The email address of the attendee
+ \sa address()
+*/
+void AgendaAttendee::setAddress(const QString& address)
+{
+ detach();
+ d->m_address = address;
+}
+
+/*!
+ Gets the email address of the attendee.
+
+ \return The email address of the attendee on success;
+ otherwise returns a null QString.
+ \sa setAddress()
+*/
+QString AgendaAttendee::address() const
+{
+ return d ? d->m_address : QString();
+}
+
+/*!
+ Sets the common name of the attendee.
+
+ \param name Common name
+ \sa commonName()
+*/
+void AgendaAttendee::setCommonName(const QString& name)
+{
+ detach();
+ d->m_commonName = name;
+}
+
+/*!
+ Gets the common name of the attendee.
+
+ \return The common name of the attendee on success;
+ otherwise returns a null QString.
+ \sa setCommonName()
+*/
+QString AgendaAttendee::commonName() const
+{
+ return d ? d->m_commonName : QString();
+}
+
+/*!
+ Sets the role of the attendee.
+
+ \param role The role
+ \sa role()
+*/
+void AgendaAttendee::setRole(AgendaAttendee::ParticipantRole role)
+{
+ detach();
+ d->m_role = role;
+}
+
+/*!
+ Gets the role of the attendee.
+
+ \return The role
+ \sa setRole()
+*/
+AgendaAttendee::ParticipantRole AgendaAttendee::role() const
+{
+ return d ? d->m_role : ParticipantRoleUnknown;
+}
+
+/*!
+ Sets the status of the attendee.
+
+ \param status Attendees's status
+ \sa status()
+ */
+void AgendaAttendee::setStatus(AgendaAttendee::StatusType status)
+{
+ detach();
+ d->m_status = status;
+}
+
+/*!
+ Gets the status of the attendee.
+
+ \return Attendees's status
+ \sa status()
+ */
+AgendaAttendee::StatusType AgendaAttendee::status() const
+{
+ return d ? d->m_status : StatusUnknown;
+}
+
+/*!
+ Sets whether or not a response is/was requested for this attendee.
+
+ \param responseRequested True if a response is/was requested, false if not.
+ \sa responseRequested()
+ */
+void AgendaAttendee::setResponseRequested(bool responseRequested)
+{
+ detach();
+ d->m_responseRequested = responseRequested;
+}
+
+/*!
+ Sets whether or not a response is/was requested for this attendee.
+
+ \return True if a response is/was requested, false if not.
+ \sa setResponseRequested()
+ */
+bool AgendaAttendee::responseRequested() const
+{
+ return d ? d->m_responseRequested : false;
+}
+
+/*!
+ Returns true if the attendee is empty; otherwise returns false.
+
+ \return true if the attendee is empty; otherwise returns false.
+*/
+bool AgendaAttendee::isNull() const
+{
+ return !d;
+}
+
+void AgendaAttendee::detach()
+{
+ if (!d) {
+ d = new AgendaAttendeePrivate;
+ } else {
+ qAtomicDetach(d);
+ }
+}
+
+/*!
+ Assigns \a other to this attendee and returns a reference
+ to this attendee.
+
+ \param other the other attendee
+ \return a reference to this attendee
+*/
+AgendaAttendee& AgendaAttendee::operator=(const AgendaAttendee& other)
+{
+ if (d == other.d)
+ {
+ return *this;
+ }
+ if (other.d)
+ {
+ other.d->ref.ref();
+ }
+ if (d && !d->ref.deref())
+ {
+ delete d;
+ }
+ d = other.d;
+ return *this;
+}
+
+
+/*!
+ Returns true if this AgendaAttendee is equal to the \a other
+ info, otherwise returns false.
+*/
+bool AgendaAttendee::operator==(const AgendaAttendee& other) const
+{
+ if (d == other.d)
+ return true;
+
+ return (d->m_address == other.d->m_address
+ && d->m_commonName == other.d->m_commonName
+ && d->m_responseRequested == other.d->m_responseRequested
+ && d->m_role == other.d->m_role
+ && d->m_status == other.d->m_status);
+}
+
+/*!
+ Returns true if this AgendaAttendee is not equal to the \a other
+ info, otherwise returns false.
+*/
+bool AgendaAttendee::operator!=(const AgendaAttendee& other) const
+{
+ return !(*this == other);
+}
+
+AgendaAttendeePrivate::AgendaAttendeePrivate()
+ : ref(1)
+{
+ m_status = AgendaAttendee::StatusConfirmed;
+}
+
+/****************************************************
+ *
+ * AgendaCategory
+ *
+ ****************************************************/
+
+/*!
+ \class AgendaCategory
+
+ \brief Calendar categories can be associated with a calendar entry.
+ There are 12 built in category types defined by CategoryType.
+ Additionally, it is possible to define extended category
+ types which are held as a string.
+ Any number of categories can be specified for an entry.
+ Calendar entry provides member functions for adding, deleting
+ and fetching categories for an entry.
+*/
+
+/*!
+ \enum AgendaCategory::CategoryType
+
+ This enum defines the possible category types for a AgendaCategory object.
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::AppointmentCategory
+ Appointment
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::BusinessCategory
+ Business
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::EducationCategory
+ Education
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::HolidayCategory
+ Holiday
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::MeetingCategory
+ Meeting
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::MiscellaneousCategory
+ All other types
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::PersonalCategory
+ Personal
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::PhoneCallCategory
+ Phone call
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::SickDayCategory
+ Sick day
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::SpecialOccasionCategory
+ Special occasion
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::TravelCategory
+ Travel
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::VacationCategory
+ Vacation
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::ExtendedCategory
+ Extended
+*/
+/*! \var AgendaCategory::CategoryType AgendaCategory::UnknownCategory
+ Unknown
+*/
+
+/*!
+ Creates a category.
+*/
+AgendaCategory::AgendaCategory()
+ : d(NULL)
+{
+}
+
+/*!
+ Creates a copy of a given category.
+
+ \param other catecory to be copied.
+ */
+AgendaCategory::AgendaCategory(const AgendaCategory& other) : d(other.d)
+{
+ if (d) {
+ d->ref.ref();
+ }
+}
+
+/*!
+ Constructs a new category using given \a category.
+
+ \param category The type of the category
+*/
+AgendaCategory::AgendaCategory(AgendaCategory::CategoryType category)
+ : d(new AgendaCategoryPrivate)
+{
+ d->m_categoryType = category;
+}
+
+/*!
+ Destroys the category.
+*/
+AgendaCategory::~AgendaCategory()
+{
+ if (d && !d->ref.deref())
+ {
+ delete d;
+ }
+}
+
+/*!
+ Sets the category type.
+
+ \param categoryType The category type
+ \sa category()
+*/
+void AgendaCategory::setCategory(AgendaCategory::CategoryType categoryType)
+{
+ detach();
+ d->m_categoryType = categoryType;
+}
+
+/*!
+ Sets the extended category name.
+
+ \param name The entended category name
+ \sa extendedCategoryName()
+*/
+void AgendaCategory::setExtendedCategoryName(const QString& name)
+{
+ detach();
+ d->m_categoryType = AgendaCategory::ExtendedCategory;
+ d->m_extendedCategory = name;
+}
+
+/*!
+ Gets the extended category name.
+
+ \return The entended category name
+ \sa setExtendedCategoryName()
+*/
+QString AgendaCategory::extendedCategoryName() const
+{
+ return d ? d->m_extendedCategory : QString();
+}
+
+/*!
+ Gets the category type.
+
+ \return The category type
+ \sa setCategory()
+*/
+AgendaCategory::CategoryType AgendaCategory::category() const
+{
+ return d ? d->m_categoryType : UnknownCategory;
+}
+
+void AgendaCategory::detach()
+{
+ if (!d) {
+ d = new AgendaCategoryPrivate();
+ } else {
+ qAtomicDetach(d);
+ }
+}
+
+/*!
+ Assigns \a other to this category and returns a reference
+ to this category.
+
+ \param other the other category
+ \return a reference to this category
+*/
+AgendaCategory& AgendaCategory::operator=(const AgendaCategory& other)
+{
+ if (d == other.d)
+ {
+ return *this;
+ }
+ if (other.d)
+ {
+ other.d->ref.ref();
+ }
+ if (d && !d->ref.deref())
+ {
+ delete d;
+ }
+ d = other.d;
+ return *this;
+}
+
+/*!
+ Returns true if this AgendaCategory is equal to the \a other
+ info, otherwise returns false.
+*/
+bool AgendaCategory::operator==(const AgendaCategory& other) const
+{
+ if (d == other.d)
+ return true;
+
+ return (d->m_categoryType == other.d->m_categoryType
+ && d->m_extendedCategory == other.d->m_extendedCategory);
+}
+
+/*!
+ Returns true if this AgendaAttendee is not equal to the \a other
+ info, otherwise returns false.
+*/
+bool AgendaCategory::operator!=(const AgendaCategory& other) const
+{
+ return !(*this == other);
+}
+
+/*!
+ Returns true if the category is empty; otherwise returns false.
+
+ \return true if the category is empty; otherwise returns false.
+*/
+bool AgendaCategory::isNull() const
+{
+ return !d;
+}
+
+AgendaCategoryPrivate::AgendaCategoryPrivate()
+ : m_categoryType(AgendaCategory::UnknownCategory)
+{
+}
+
+/****************************************************
+ *
+ * AgendaAlarm
+ *
+ ****************************************************/
+
+/*!
+ \class AgendaAlarm
+
+ \brief Class representing an alarm.
+ This can be assigned to a calendar entry.
+*/
+
+/*!
+ Creates an alarm.
+*/
+AgendaAlarm::AgendaAlarm() : d(NULL)
+{
+}
+
+/*!
+ Creates a copy of a given alarm.
+
+ \param other alarm to be copied.
+*/
+AgendaAlarm::AgendaAlarm(const AgendaAlarm& other) : d(other.d)
+{
+ if (d) {
+ d->ref.ref();
+ }
+}
+
+/*!
+ Destroys the alarm.
+*/
+AgendaAlarm::~AgendaAlarm()
+{
+ if (d && !d->ref.deref())
+ {
+ delete d;
+ }
+}
+
+/*! \var AgendaAlarm::MaxFileNameLength
+ Maximum file lenght for the alarm
+*/
+
+/*!
+ Sets a time offset for an alarm to occur prior to a scheduled event.
+ The time offset is calculated as the number of minutes before the instance time of the event.
+ It is possible to have a negative offset provided that the alarm is
+ on the same day (in local time) as the instance time; this means the alarm occurs
+ after the event.
+
+ \param minutes The time offset in minutes for an alarm prior to an event.
+ \sa timeOffset()
+*/
+void AgendaAlarm::setTimeOffset(int minutes)
+{
+ detach();
+ d->m_timeOffset = minutes;
+}
+
+/*!
+ Gets the time offset for the alarm to occur prior to an event.
+
+ \return The alarm offset (in minutes) prior to an event on success;
+ otherwise return -1.
+ \sa setTimeOffset()
+*/
+int AgendaAlarm::timeOffset() const
+{
+ return d ? d->m_timeOffset : -1;
+}
+
+/*!
+ Sets the name of the alarm sound.
+ If this isn't set then the default alarm sound will be used.
+ Note: if the length of the new alarm sound name is greater than MaxFileNameLength characters,
+ it will be ignored.
+
+ \param alarmSoundName Sound name
+ \sa alarmSoundName()
+*/
+void AgendaAlarm::setAlarmSoundName(const QString& alarmSoundName)
+{
+ detach();
+ d->m_soundName = alarmSoundName;
+}
+
+/*!
+ Gets the name of the alarm sound.
+
+ \return Sound name on success;
+ otherwise returns a null QString.
+
+ \sa setAlarmSoundName()
+*/
+QString AgendaAlarm::alarmSoundName() const
+{
+ return d ? d->m_soundName : QString();
+}
+
+/*!
+ Returns true if the alarlm is empty; otherwise returns false.
+
+ \return true if the alarm is empty; otherwise returns false.
+ */
+bool AgendaAlarm::isNull() const
+ {
+ return !d;
+ }
+
+/*!
+ Assigns \a other to this alarm and returns a reference
+ to this alarm.
+
+ \param other the other alarm
+ \return a reference to this alarm
+ */
+AgendaAlarm& AgendaAlarm::operator=(const AgendaAlarm& other)
+{
+ if (d == other.d) {
+ return *this;
+ }
+ if (other.d) {
+ other.d->ref.ref();
+ }
+ if (d && !d->ref.deref()) {
+ delete d;
+ }
+ d = other.d;
+ return *this;
+}
+
+/*!
+ Returns true if this AgendaAlarm is equal to the \a other
+ info, otherwise returns false.
+ */
+bool AgendaAlarm::operator==(const AgendaAlarm& other) const
+{
+ if (d == other.d) {
+ return true;
+ }
+
+ if (!d || !other.d) {
+ return false;
+ }
+
+ return (d->m_soundName == other.d->m_soundName
+ && d->m_timeOffset == other.d->m_timeOffset);
+}
+
+/*!
+ Returns true if this AgendaAlarm is not equal to the \a other
+ info, otherwise returns false.
+ */
+bool AgendaAlarm::operator!=(const AgendaAlarm& other) const
+{
+ return !(*this == other);
+}
+
+void AgendaAlarm::detach()
+{
+ if (!d) {
+ d = new AgendaAlarmPrivate;
+ } else {
+ qAtomicDetach(d);
+ }
+}
+
+AgendaAlarmPrivate::AgendaAlarmPrivate()
+:ref(1)
+{
+ // Nothing to do.
+}
+
+/****************************************************
+ *
+ * AgendaRepeatRule
+ *
+ ****************************************************/
+
+/*!
+ \class AgendaRepeatRule
+
+ \brief Class representing a repeat rule types.
+
+ This supports the following standard iCal properties:
+
+ FREQ (rule type),
+ DTSTART (start date),
+ UNTIL (end date),
+ COUNT (number of instances),
+ INTERVAL (interval between instances),
+ BYDAY,
+ BYMONTHDAY,
+ BYYEARDAY,
+ WKST (start day of week).
+
+ Note that the repeat rule type (FREQ) must be set before any of the following properties
+ can be set, since their behaviour is dependent on the rule type:
+ BYDAY, BYMONTHDAY, BYYEARDAY
+ The WKST parameter is only significant in weekly repeat rules with an interval of
+ greater than 1.
+
+ The repeat rule type may not be changed once it has been set.
+*/
+
+/*!
+ \enum AgendaRepeatRule::RuleType
+
+ This enum defines the possible rule types for a AgendaRepeatRule object.
+*/
+/*! \var AgendaRepeatRule::RuleType AgendaRepeatRule::DailyRule
+ Rule which repeats based on a number of days.
+*/
+/*! \var AgendaRepeatRule::RuleType AgendaRepeatRule::WeeklyRule
+ Rule which repeats based on a number of weeks.
+*/
+/*! \var AgendaRepeatRule::RuleType AgendaRepeatRule::MonthlyRule
+ Rule which repeats based on a number of months.
+*/
+/*! \var AgendaRepeatRule::RuleType AgendaRepeatRule::YearlyRule
+ Rule which repeats based on a number of years.
+*/
+/*! \var AgendaRepeatRule::RuleType AgendaRepeatRule::InvalidRule
+ The type has not yet been defined.
+*/
+
+/*!
+ \enum AgendaRepeatRule::Day
+
+ The days are presented as enums
+*/
+/*! \var AgendaRepeatRule::Day AgendaRepeatRule::Monday */
+/*! \var AgendaRepeatRule::Day AgendaRepeatRule::Tuesday */
+/*! \var AgendaRepeatRule::Day AgendaRepeatRule::Wednesday */
+/*! \var AgendaRepeatRule::Day AgendaRepeatRule::Thursday */
+/*! \var AgendaRepeatRule::Day AgendaRepeatRule::Friday */
+/*! \var AgendaRepeatRule::Day AgendaRepeatRule::Saturday */
+/*! \var AgendaRepeatRule::Day AgendaRepeatRule::Sunday */
+/*! \var AgendaRepeatRule::Day AgendaRepeatRule::InvalidDay */
+
+/*!
+ \enum AgendaRepeatRule::Day
+
+ The months are presented as enums
+*/
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::January */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::February */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::March */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::April */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::May */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::June */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::July */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::August */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::September */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::October */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::November */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::December */
+/*! \var AgendaRepeatRule::Month AgendaRepeatRule::InvalidMonth */
+
+/*!
+ Creates a repeat rule.
+*/
+AgendaRepeatRule::AgendaRepeatRule() : d(NULL)
+{
+
+}
+
+/*!
+ Constructs a new repeat rule using given \a type.
+
+ \param type The type of the rule
+*/
+AgendaRepeatRule::AgendaRepeatRule(AgendaRepeatRule::RuleType type)
+ : d(new AgendaRepeatRulePrivate)
+{
+ d->m_repeatRuleType = type;
+ d->ref.ref();
+}
+
+/*!
+ Creates a copy of a given repeat rule.
+
+ \param other repeat rule to be copied.
+*/
+AgendaRepeatRule::AgendaRepeatRule(const AgendaRepeatRule& other)
+ : d(other.d)
+{
+ if (d) {
+ d->ref.ref();
+ }
+}
+
+/*!
+ Destroys the repeat rule.
+*/
+AgendaRepeatRule::~AgendaRepeatRule()
+{
+ if (d && !d->ref.deref())
+ {
+ delete d;
+ }
+}
+
+/*!
+ Sets the repeat definition's type.
+ This will be one of: daily, weekly, monthly or yearly.
+ If the type is weekly, it must have at least one weekday set by calling setByDay().
+ The type may only be set once, from either the constructor or from the setType() function.
+
+ \param type The repeat definition's type.
+ \sa type()
+*/
+void AgendaRepeatRule::setType(AgendaRepeatRule::RuleType type)
+{
+ detach();
+ d->m_repeatRuleType = type;
+}
+
+/*!
+ Gets the repeat definition's type.
+ This will be one of: daily, weekly, monthly or yearly.
+
+ \return The repeat definition's type.
+ \sa setType()
+*/
+AgendaRepeatRule::RuleType AgendaRepeatRule::type() const
+{
+ return d ? d->m_repeatRuleType : InvalidRule;
+}
+
+/*!
+ Sets the repeat interval.
+ This is a number of days for a daily repeat, a number of weeks for a weekly repeat, etc.
+
+ \param interval Any parameter that is greater than 255 or less than 1 will be ignored.
+ \sa interval()
+*/
+void AgendaRepeatRule::setInterval(int interval)
+{
+ detach();
+ if (interval <= 255 && interval >= 1)
+ {
+ d->m_interval = interval;
+ }
+}
+
+/*!
+ Gets the repeat interval.
+ This is a number of days for a daily repeat, a number of weeks for a weekly repeat, etc.
+
+ \return The interval in minutes on success;
+ otherwise returns -1.
+
+ \sa interval()
+*/
+int AgendaRepeatRule::interval() const
+{
+ return d ? d->m_interval : -1;
+}
+
+/*!
+ Sets the repeat's start date.
+
+ \param date The start date
+ \sa repeatRuleStart()
+*/
+void AgendaRepeatRule::setRepeatRuleStart(const QDate& date)
+{
+ detach();
+ d->m_startDate = date;
+}
+
+/*!
+ Gets the repeat's start date.
+
+ \return The start date on success;
+ otherwise returns a null QDate.
+
+ \sa setRepeatRuleStart()
+*/
+QDate AgendaRepeatRule::repeatRuleStart() const
+{
+ return d ? d->m_startDate : QDate();
+}
+
+/*!
+ Sets the repeat's end date.
+
+ \parm date The end date
+ \sa setUntil()
+*/
+void AgendaRepeatRule::setUntil(const QDate& date)
+{
+ detach();
+ d->m_untilDate = date;
+}
+
+/*!
+ Gets the repeat's end date.
+
+ \return The end date on success;
+ otherwise returns a null QDate.
+ \sa setUntil()
+*/
+QDate AgendaRepeatRule::until() const
+{
+ return d ? d->m_untilDate : QDate();
+}
+
+/*!
+ Sets the first day of the week for this repeat rule.
+
+ \param day The weekday to be the first
+ \sa weekStart()
+*/
+void AgendaRepeatRule::setWeekStart(Day day)
+{
+ detach();
+ d->m_weekStartDay = day;
+}
+
+/*!
+ Gets the first day of the week for this repeat rule.
+
+ \return The first weekday
+ \sa setWeekStart()
+*/
+AgendaRepeatRule::Day AgendaRepeatRule::weekStart() const
+{
+ return d ? d->m_weekStartDay : InvalidDay;
+}
+
+/*!
+ Set all weekdays on which this rule is repeated.
+
+ \param days List containing all weekdays that are to be set.
+ Any weekdays not included in this array will not be set.
+ \sa getByDay()
+*/
+void AgendaRepeatRule::setByDay(const QList<Day>& days)
+{
+ detach();
+ d->m_days = days;
+}
+
+/*!
+ Gets all weekdays on which this rule is repeated.
+
+ \return List contains all weekdays that are to be set on success;
+ otherwise returns a null list.
+ \sa setByDay()
+*/
+QList<AgendaRepeatRule::Day> AgendaRepeatRule::byDay() const
+{
+ return d ? d->m_days : QList<AgendaRepeatRule::Day>();
+}
+
+/*!
+ Sets all dates of the month on which this rule is repeated.
+
+ \param monthDays List containing all month dates that are to be set.
+ \sa byMonthDay()
+*/
+void AgendaRepeatRule::setByMonthDay(const QList<int>& monthDays)
+{
+ detach();
+ d->m_monthDays = monthDays;
+}
+
+/*!
+ Gets all dates of the month on which this rule is repeated.
+
+ \return List contains all month dates that are to be set on success;
+ otherwise returns a null list.
+
+ \sa setByMonthDay()
+*/
+QList<int> AgendaRepeatRule::byMonthDay() const
+{
+ return d ? d->m_monthDays : QList<int>();
+}
+
+/*!
+ Sets the month of the year for this repeat rule.
+
+ \param months List of months on which to repeat.
+ Only the first month in the array is used.
+ \sa byMonth()
+*/
+void AgendaRepeatRule::setByMonth(const QList<Month>& months)
+{
+ detach();
+ d->m_months = months;
+}
+
+/*!
+ Gets the month of the year for this repeat rule.
+
+ \return List of months on which to repeat on success;
+ otherwise returns a null list.
+ .
+ \sa setByMonth()
+*/
+QList<AgendaRepeatRule::Month> AgendaRepeatRule::byMonth() const
+{
+ return d ? d->m_months : QList<AgendaRepeatRule::Month>();
+}
+
+void AgendaRepeatRule::detach()
+{
+ if (!d) {
+ d = new AgendaRepeatRulePrivate();
+ } else {
+ qAtomicDetach(d);
+ }
+}
+
+/*!
+ Returns true if the repeatrule is empty; otherwise returns false.
+
+ \return true if the repeatrule is empty; otherwise returns false.
+*/
+bool AgendaRepeatRule::isNull() const
+{
+ return !d;
+}
+
+/*!
+ Assigns \a other to this repeat rule and returns a reference
+ to this repeat rule.
+
+ \param other the other repeat rule
+ \return a reference to this repeat rule
+*/
+AgendaRepeatRule& AgendaRepeatRule::operator=(const AgendaRepeatRule& other)
+{
+ if (d == other.d)
+ {
+ return *this;
+ }
+ if (other.d)
+ {
+ other.d->ref.ref();
+ }
+ if (d && !d->ref.deref())
+ {
+ delete d;
+ }
+ d = other.d;
+ return *this;
+}
+
+
+/*!
+ Returns true if this AgendaRepeatRule is equal to the \a other
+ info, otherwise returns false.
+*/
+bool AgendaRepeatRule::operator==(const AgendaRepeatRule& other) const
+{
+ if (d == other.d)
+ return true;
+
+ return (d->m_days == other.d->m_days
+ && d->m_interval == other.d->m_interval
+ && d->m_monthDays == other.d->m_monthDays
+ && d->m_months == other.d->m_months
+ && d->m_repeatRuleType == other.d->m_repeatRuleType
+ && d->m_startDate == other.d->m_startDate
+ && d->m_untilDate == other.d->m_untilDate
+ && d->m_weekStartDay == other.d->m_weekStartDay);
+}
+
+/*!
+ Returns true if this AgendaRepeatRule is not equal to the \a other
+ info, otherwise returns false.
+*/
+bool AgendaRepeatRule::operator!=(const AgendaRepeatRule& other) const
+{
+ return !(*this == other);
+}
+
+AgendaRepeatRulePrivate::AgendaRepeatRulePrivate() : ref(1)
+{
+
+}
+
+/****************************************************
+ *
+ * AgendaEntry
+ *
+ ****************************************************/
+
+/*!
+ \class AgendaEntry
+
+ \brief Class representing a calendar entry.
+ This can be an appointment, to-do item, reminder, event or anniversary.
+ AgendaEntry contains information about a calendar entry.
+*/
+
+/*!
+ \enum AgendaEntry::Type
+
+ This enum defines the possible entry types for a AgendaEntry object.
+*/
+/*! \var AgendaEntry::Type AgendaEntry::TypeAppoinment
+ An appointment, which has a start time and end time.
+*/
+/*! \var AgendaEntry::Type AgendaEntry::TypeTodo
+ A to-do, which can have a start time and end time
+ (the end time is the due date), or can be undated.
+*/
+/*! \var AgendaEntry::Type AgendaEntry::TypeEvent
+ An event, which has a start time and end time.
+*/
+/*! \var AgendaEntry::Type AgendaEntry::TypeReminder
+ A reminder, which has a start time only.
+*/
+/*! \var AgendaEntry::Type AgendaEntry::TypeAnniversary
+ An anniversary, which has a start time and end time.
+*/
+/*! \var AgendaEntry::Type AgendaEntry::TypeNote
+ A Note, which has description and can be a favorite entry.
+ */
+/*! \var AgendaEntry::Type AgendaEntry::TypeUnknown
+ The type is unknown.
+*/
+
+/*!
+ \enum AgendaEntry::Method
+
+ This enum defines the possible methods for a AgendaEntry object.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodNone
+ The RFC2445-defined method value 'None'.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodPublish
+ The RFC2445-defined method value 'Publish'.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodRequest
+ The RFC2445-defined method value 'Request'.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodReply
+ The RFC2445-defined method value 'Reply'.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodAdd
+ The RFC2445-defined method value 'Add'.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodCancel
+ The RFC2445-defined method value 'Cancel'.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodRefresh
+ The RFC2445-defined method value 'Refresh'.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodCounter
+ The RFC2445-defined method value 'Counter'.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodDeclineCounter
+ The RFC2445-defined method value 'DeclineCounter'.
+*/
+/*! \var AgendaEntry::Method AgendaEntry::MethodUnknown
+ The method is unknown
+*/
+
+/*!
+ \enum AgendaEntry::Status
+
+ This enum defines the possible status properties as per RFC-2445 and
+ vCalendar 1.0 standard.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::Tentative
+ Used to support iCalendar (RFC 2445) and vCalendar 1.0.
+ The event is tentative.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::Confirmed
+ Used to support iCalendar (RFC 2445) and vCalendar 1.0.
+ The event has been confirmed.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::Cancelled
+ Used to support iCalendar (RFC 2445). The event has been cancelled.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::TodoNeedsAction
+ Used to support iCalendar (RFC 2445). The to-do entry needs action.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::TodoCompleted
+ Used to support iCalendar (RFC 2445) and vCalendar 1.0.
+ The to-do entry has been completed.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::TodoInProcess
+ Used to support iCalendar (RFC 2445). The to-do entry is in progress.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::NullStatus
+ No status is set.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::VCalAccepted
+ Used to support vCalendar 1.0. The entry has been accepted.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::VCalNeedsAction
+ Used to support vCalendar 1.0. The entry needs action.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::VCalSent
+ Used to support vCalendar 1.0. The entry has been sent.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::VCalDeclined
+ Used to support vCalendar 1.0. The entry has been declined.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::VCalDelegated
+ Used to support vCalendar 1.0. The entry has been delegated.
+ */
+/*! \var AgendaEntry::Status AgendaEntry::StatusUnknown
+ Unknown status.
+ */
+
+/*!
+ Creates a calendar entry.
+ */
+AgendaEntry::AgendaEntry() : d(NULL)
+{
+}
+
+/*!
+ Constructs a new entry rule using given \a type.
+
+ \param type The type of the entry
+ */
+AgendaEntry::AgendaEntry(Type type) : d(new AgendaEntryPrivate)
+{
+ d->m_entryType = type;
+ d->ref.ref();
+}
+
+/*!
+ Creates a copy of a given entry.
+
+ \param other entry to be copied.
+ */
+AgendaEntry::AgendaEntry(const AgendaEntry& other) : d(other.d)
+{
+ if (d) {
+ d->ref.ref();
+ }
+}
+
+/*!
+ Destroys the entry.
+ */
+AgendaEntry::~AgendaEntry()
+{
+ if (d && !d->ref.deref()) {
+ delete d;
+ }
+}
+
+/*!
+ Adds an attendee for this entry.
+
+ \param The attendee to be added.
+ \sa attendies(), deleteAttendee()
+ */
+void AgendaEntry::addAttendee(const AgendaAttendee& attendee)
+{
+ detach();
+ d->addAttendee(attendee);
+}
+
+/*!
+ Returns true if the calendar entry is empty; otherwise returns false.
+
+ \return true if the Calendar entry is empty; otherwise returns false.
+ */
+bool AgendaEntry::isNull() const
+{
+ return !d;
+}
+
+/*!
+ Sets the alarm for the entry. Alarm can be removed by setting
+ null AgendaAlarm with this function.
+
+ \param alarm Alarm object to be set
+ \sa alarm()
+ */
+void AgendaEntry::setAlarm(const AgendaAlarm& alarm)
+{
+ detach();
+ d->m_alarm = alarm;
+}
+
+/*!
+ Gets the alarm for the entry
+
+ \return Alarm object on success;
+ otherwise returns a null AgendaAlarm.
+
+ \sa setAlarm()
+ */
+AgendaAlarm AgendaEntry::alarm() const
+{
+ return d ? d->m_alarm : AgendaAlarm();
+}
+
+/*!
+ Sets the start and end date/times for an entry.
+
+ For an appointment, event or anniversary, the start time must be earlier
+ than or equal to the end time. For a reminder, the end time will be ignored.
+ For a to-do entry, the end time is the 'due date'. The time portion of the start date
+ will not be stored for todos, only the number of days until the due date.
+ Only Undated To-do's can have both start and end date as NullTime.
+
+ \param startTime The entry's new start date/time.
+ \param endTime The entry's new end date/time.
+ \return true if the start and end times are valid; otherwise returns false.
+ \sa startTime(), endTime()
+ */
+bool AgendaEntry::setStartAndEndTime(
+ const QDateTime& startTime, const QDateTime& endTime)
+{
+ detach();
+ d->m_startTime = startTime;
+ d->m_endTime = endTime;
+
+ return true;
+}
+
+/*!
+ Gets the start date/time for an entry.
+
+ \return The entry's start date/time on success;
+ otherwise returns a null QDateTime.
+ \sa endTime(), setStartAndEndTime()
+ */
+QDateTime AgendaEntry::startTime() const
+{
+ return d ? d->m_startTime : QDateTime();
+}
+
+/*!
+ Gets the entry's end date/time.
+
+ \return The entry's end date/time on success;
+ otherwise returns a null QDateTime.
+ \sa startTime(), setStartAndEndTime()
+ */
+QDateTime AgendaEntry::endTime() const
+{
+ return d ? d->m_endTime : QDateTime();
+}
+
+/*!
+ Returns a reference to the attendees list.
+ Using a reference makes it possible to manipulate the list directly.
+
+ \return A reference to the attendees list
+ \sa startTime(), setStartAndEndTime()
+ */
+QList<AgendaAttendee>& AgendaEntry::attendees()
+{
+ return d->m_attendees;
+}
+
+/*!
+ Returns a const reference to the attendees list.
+
+ \return A const reference to the attendees list
+ \sa startTime(), setStartAndEndTime()
+ */
+const QList<AgendaAttendee>& AgendaEntry::attendees() const
+{
+ return d->m_attendees;
+}
+
+/*!
+ Returns a const reference to the attendees list.
+
+ \return A const reference to the attendees list
+ \sa addCategory(), deleteCategory()
+ */
+const QList<AgendaCategory>& AgendaEntry::categories() const
+{
+ return d->m_categories;
+}
+
+/*!
+ Sets the description text for this entry.
+
+ \param description The description text
+ \sa description()
+ */
+void AgendaEntry::setDescription(const QString& description)
+{
+ detach();
+ d->m_description = description;
+}
+
+/*!
+ Gets the description text for the entry.
+
+ \return The description text on success;
+ otherwise returns a null QString.
+ \sa setDescription()
+ */
+QString AgendaEntry::description() const
+{
+ return d ? d->m_description : QString();
+}
+
+/*!
+ Gets a list of the entry's categories.
+
+ \return A const reference to the attendees list
+ \sa addCategory(), deleteCategory()
+ */
+QList<AgendaCategory>& AgendaEntry::categories()
+{
+ return d->m_categories;
+}
+
+/*!
+ Gets the local uid of the entry.
+
+ \return Entry id on success;
+ otherwise returns -1.
+ */
+ulong AgendaEntry::id() const
+{
+ return d ? d->m_id : 0;
+}
+
+/*!
+ Gets the type of entry.
+
+ \return The type of entry.
+ */
+AgendaEntry::Type AgendaEntry::type() const
+{
+ return d ? d->m_entryType : TypeUnknown;
+}
+
+/*!
+ Sets the type of entry.
+
+ \param type The type of entry.
+ \sa type()
+ */
+void AgendaEntry::setType(Type type)
+{
+ detach();
+ d->m_entryType = type;
+}
+
+/*!
+ Appends a category to the entry's list of categories.
+
+ \param category The category to be added
+ \sa deleteCategory(), categories()
+ */
+void AgendaEntry::addCategory(const AgendaCategory& category)
+{
+ detach();
+ d->addCategory(category);
+}
+
+/*!
+ Sets the contents of the entry's location field.
+
+ \return Descriptor containing a location, e.g. for a meeting.
+ \sa location()
+ */
+void AgendaEntry::setLocation(const QString& location)
+{
+ detach();
+ d->m_location = location;
+}
+
+/*!
+ Gets the contents of the entry's location field.
+
+ \return The location field on success;
+ otherwise returns a null QString.
+ \sa setLocation()
+ */
+QString AgendaEntry::location() const
+{
+ return d ? d->m_location : QString();
+}
+
+/*!
+ Sets the summary text for this entry.
+
+ \param summary The summary text.
+ \sa summary()
+ */
+void AgendaEntry::setSummary(const QString& summary)
+{
+ detach();
+ d->m_summaryText = summary;
+}
+
+/*!
+ Gets the summary for the entry.
+
+ \return The summary text on success;
+ otherwise returns a null QString.
+ \sa setSummary()
+ */
+QString AgendaEntry::summary() const
+{
+ return d ? d->m_summaryText : QString();
+}
+
+/*!
+ Sets the entry's method property for group scheduling.
+
+ \param method The method property of a Group Scheduling entry
+ \sa method()
+ */
+void AgendaEntry::setMethod(Method method)
+{
+ detach();
+ d->m_method = method;
+}
+
+/*!
+ Returns the entry's method property for group scheduling.
+
+ \return The method property of a Group Scheduling entry
+ \sa setMethod()
+ */
+AgendaEntry::Method AgendaEntry::method() const
+{
+ return d ? d->m_method : MethodUnknown;
+}
+
+/*!
+ Sets the entry's repeat definition.
+
+ \param repetRule Repeat rule object
+ \sa repeatRule()
+ */
+void AgendaEntry::setRepeatRule(const AgendaRepeatRule& repeatRule)
+{
+ detach();
+ d->m_repeatRule = repeatRule;
+}
+
+/*!
+ Gets the entry's repeat rule. Count and the Until values can be accessed.
+ Note! In the case of a repeat rule which repeats forever,
+ the Count will always be returned as 0.
+
+ \return AgendaRepeatRule Repeat rule object on success;
+ otherwise returns a null AgendaRepeatRule.
+ \sa setRepeatRule()
+ */
+AgendaRepeatRule AgendaEntry::repeatRule() const
+{
+ return d ? d->m_repeatRule : AgendaRepeatRule();
+}
+
+/*!
+ Sets the priority for the entry. The default value is zero.
+
+ \param priority Priority value between 0 and 255.
+ The behaviour is undefined if the priority is greater than 255.
+ \sa priority()
+ */
+void AgendaEntry::setPriority(int priority)
+{
+ detach();
+ d->m_priority = priority;
+}
+
+/*!
+ Gets the priority of the entry.
+
+ \return Priority value between 0 and 255 on success;
+ otherwise returns -1.
+ \sa setPriority()
+ */
+int AgendaEntry::priority() const
+{
+ return d ? d->m_priority : -1;
+}
+
+/*!
+ Sets the rDates for the entry.
+
+ \param rDates Random dates to be set for the entry
+ \sa rDates()
+ */
+void AgendaEntry::setRDates(const QList<QDate>& rdates)
+{
+ detach();
+ d->m_rDates = rdates;
+}
+
+/*!
+ Gets the rDates of the entry.
+
+ \return RDates Returns the rendom dates if entry has any;
+ otherwise returns empty list.
+ \sa setRDates()
+*/
+QList<QDate> AgendaEntry::rDates() const
+{
+ return d ? d->m_rDates : QList<QDate>();
+}
+
+/*!
+ Sets the recurrence Id of an entry
+
+ \param recTime recurrence Id
+*/
+void AgendaEntry::setRecurrenceId(QDateTime& recTime)
+{
+ detach();
+ d->m_recurrenceId = recTime;
+}
+
+/*!
+ Returns the recurrence Id of an entry
+
+ return bool returns true if the entry is repeated else false
+*/
+QDateTime AgendaEntry::recurrenceId()
+{
+ return d ? d->m_recurrenceId : QDateTime();
+}
+
+/*!
+ Constructs the P-IMPL if not already there.
+ */
+void AgendaEntry::detach()
+{
+ if (!d) {
+ d = new AgendaEntryPrivate;
+ } else {
+ qAtomicDetach(d);
+ }
+}
+
+/*!
+ Informs if the entry is a timed entry or not
+
+ return bool returns true if the entry is timed else false
+*/
+bool AgendaEntry::isTimedEntry()
+{
+ return type() == TypeAppoinment || type() == TypeReminder;
+}
+
+/*!
+ Informs if the entry is a repeated entry or not
+
+ return bool returns true if the entry is repeated else false
+*/
+bool AgendaEntry::isRepeating()
+{
+ bool repeating = false;
+ bool rdate = rDates().count() > 0;
+
+ if (rdate ||
+ (this->repeatRule().type() != AgendaRepeatRule::InvalidRule)) {
+ repeating = true;
+ }
+
+ return repeating;
+}
+
+/*!
+ Returns the last modification time for the entry.
+
+ \return QDateTime object containing the last modified time.
+ */
+QDateTime AgendaEntry::lastModifiedDateTime() const
+{
+ return d ? d->m_lastModTime : QDateTime();
+}
+
+/*!
+ Sets the last modification time for the entry.
+
+ \param dateTime Of type QDateTime, holds the last modified time.
+ */
+void AgendaEntry::setLastModifiedDateTime(const QDateTime& dateTime)
+{
+ detach();
+ d->m_lastModTime = dateTime;
+}
+
+/*!
+ Returns the status of the entry.
+
+ \return AgendaEntry::Status The status of the entry.
+ */
+AgendaEntry::Status AgendaEntry::status() const
+{
+ return d ? d->m_entryStatus : StatusUnknown;
+}
+
+/*!
+ Sets the status of the entry.
+
+ \param newStatus AgendaEntry::Status argument.
+ */
+void AgendaEntry::setStatus(AgendaEntry::Status newStatus)
+{
+ detach();
+ d->m_entryStatus = newStatus;
+}
+
+/*!
+ Returns the value of favourite property for the entry.
+
+ \return uint 0 or 1 depending on whether the entry is marked as favourite or
+ not.
+ */
+uint AgendaEntry::favourite() const
+{
+ return d ? d->m_favourite : 0;
+}
+
+/*!
+ Sets or resets the favourite property for an entry. The value should be 0
+ for un-marking it as favourite and 1 for marking it as favourite.
+ */
+void AgendaEntry::setFavourite(uint favourite)
+{
+ detach();
+ d->m_favourite = favourite;
+}
+
+/*!
+ Sets the to-do completion data and time.This method can be used by
+ AgendaUtil to set the completed date while converting from CCalEntry to
+ Agenda Entry
+
+ \param dateTime of type QDateTime holds the to-do completion date
+ */
+void AgendaEntry::setCompletedDateTime(const QDateTime& dateTime)
+{
+ d->m_completedDateTime = dateTime;
+}
+
+/*!
+ Returns to-do completion date and time.
+
+ \return QDateTime object containing the to-do completion date and time
+ */
+QDateTime AgendaEntry::completedDateTime() const
+{
+ return d->m_completedDateTime;
+}
+
+/*!
+ Returns
+ duration of the meeting in seconds
+ \return int duration in seconds
+ */
+int AgendaEntry::durationInSecs() const
+{
+ // Calculate the duration
+ QDateTime start = d->m_startTime;
+ QDateTime end = d->m_endTime;
+ TDateTime startDateTime(start.date().year(),
+ static_cast<TMonth> (start.date().month() - 1),
+ start.date().day() - 1, start.time().hour(),
+ start.time().minute(), start.time().second(), 0);
+
+ TDateTime endDateTime(end.date().year(),
+ static_cast<TMonth> (end.date().month() - 1),
+ end.date().day() - 1, end.time().hour(),
+ end.time().minute(), end.time().second(), 0);
+
+ TTime startTime(startDateTime);
+ TTime endTime(endDateTime);
+ TTimeIntervalSeconds duration;
+ endTime.SecondsFrom(startTime, duration);
+
+ return (duration.Int());
+}
+
+/*!
+ Assigns \a other to this entry and returns a reference
+ to this entry.
+
+ \param other the other entry
+ \return a reference to this entry
+ */
+AgendaEntry& AgendaEntry::operator=(const AgendaEntry& other)
+{
+ if (d == other.d) {
+ return *this;
+ }
+ if (other.d) {
+ other.d->ref.ref();
+ }
+ if (d && !d->ref.deref()) {
+ delete d;
+ }
+ d = other.d;
+ return *this;
+}
+
+/*!
+ Returns true if this AgendaEntry is equal to the \a other
+ info, otherwise returns false.
+ */
+bool AgendaEntry::operator==(const AgendaEntry& other) const
+{
+ if (d == other.d) {
+ return true;
+ }
+
+ return (d->m_alarm == other.d->m_alarm
+ && d->m_attendees == other.d->m_attendees
+ && d->m_categories == other.d->m_categories
+ && d->m_description == other.d->m_description
+ && d->m_endTime == other.d->m_endTime
+ && d->m_entryType == other.d->m_entryType
+ && d->m_id == other.d->m_id
+ && d->m_location == other.d->m_location
+ && d->m_method == other.d->m_method
+ && d->m_priority == other.d->m_priority
+ && d->m_repeatRule == other.d->m_repeatRule
+ && d->m_startTime == other.d->m_startTime
+ && d->m_summaryText == other.d->m_summaryText
+ && d->m_lastModTime == other.d->m_lastModTime
+ && d->m_entryStatus == other.d->m_entryStatus
+ && d->m_favourite == other.d->m_favourite
+ && d->m_completedDateTime == other.d->m_completedDateTime);
+}
+
+/*!
+ Returns true if this AgendaEntry is not equal to the \a other
+ info, otherwise returns false.
+ */
+bool AgendaEntry::operator!=(const AgendaEntry& other) const
+{
+ return !(*this == other);
+}
+
+AgendaEntryPrivate::AgendaEntryPrivate() : ref(1)
+{
+ m_method = AgendaEntry::MethodNone;
+ m_entryStatus = AgendaEntry::NullStatus;
+ m_repeatRule = AgendaRepeatRule(AgendaRepeatRule::InvalidRule);
+ m_id = 0;
+ m_priority = -1;
+ m_favourite = 0;
+ m_alarm = AgendaAlarm();
+}
+
+bool AgendaEntryPrivate::deleteCategory(const AgendaCategory& category)
+{
+ for (int i = 0; i < m_categories.count(); i++) {
+ if (m_categories.at(i) == category) {
+ m_categories.removeAt(i);
+ return true;
+ }
+ }
+ return false;
+}
+
+void AgendaEntryPrivate::addCategory(const AgendaCategory& category)
+{
+ m_categories.append(category);
+}
+
+bool AgendaEntryPrivate::deleteAttendee(const AgendaAttendee& attendee)
+{
+ for (int i = 0; i < m_attendees.count(); i++) {
+ if (m_attendees.at(i).address() == attendee.address()) {
+ m_attendees.removeAt(i);
+ return true;
+ }
+ }
+ return false;
+}
+
+void AgendaEntryPrivate::addAttendee(const AgendaAttendee& attendee)
+{
+ m_attendees.append(attendee);
+}
+
+// End of file