summaryrefslogtreecommitdiffstats
path: root/kalarm/alarmevent.h
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 (patch)
tree67208f7c145782a7e90b123b982ca78d88cc2c87 /kalarm/alarmevent.h
downloadtdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.tar.gz
tdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kalarm/alarmevent.h')
-rw-r--r--kalarm/alarmevent.h500
1 files changed, 500 insertions, 0 deletions
diff --git a/kalarm/alarmevent.h b/kalarm/alarmevent.h
new file mode 100644
index 000000000..ff8ab3056
--- /dev/null
+++ b/kalarm/alarmevent.h
@@ -0,0 +1,500 @@
+/*
+ * alarmevent.h - represents calendar alarms and events
+ * Program: kalarm
+ * Copyright © 2001-2008 by David Jarvie <djarvie@kde.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KALARMEVENT_H
+#define KALARMEVENT_H
+
+/** @file alarmevent.h - represents calendar alarms and events */
+
+#include <qcolor.h>
+#include <qfont.h>
+
+#include <libkcal/person.h>
+#include <libkcal/event.h>
+namespace KCal {
+ class Calendar;
+ class CalendarLocal;
+}
+
+#include "datetime.h"
+#include "karecurrence.h"
+
+class AlarmCalendar;
+class KARecurrence;
+struct AlarmData;
+
+
+typedef KCal::Person EmailAddress;
+class EmailAddressList : public QValueList<KCal::Person>
+{
+ public:
+ EmailAddressList() : QValueList<KCal::Person>() { }
+ EmailAddressList(const QValueList<KCal::Person>& list) { operator=(list); }
+ EmailAddressList& operator=(const QValueList<KCal::Person>&);
+ QString join(const QString& separator) const;
+};
+
+
+// Base class containing data common to KAAlarm and KAEvent
+class KAAlarmEventBase
+{
+ public:
+ ~KAAlarmEventBase() { }
+ const QString& cleanText() const { return mText; }
+ QString message() const { return (mActionType == T_MESSAGE || mActionType == T_EMAIL) ? mText : QString::null; }
+ QString fileName() const { return (mActionType == T_FILE) ? mText : QString::null; }
+ QString command() const { return (mActionType == T_COMMAND) ? mText : QString::null; }
+ uint emailFromId() const { return mEmailFromIdentity; }
+ const EmailAddressList& emailAddresses() const { return mEmailAddresses; }
+ QString emailAddresses(const QString& sep) const { return mEmailAddresses.join(sep); }
+ const QString& emailSubject() const { return mEmailSubject; }
+ const QStringList& emailAttachments() const { return mEmailAttachments; }
+ QString emailAttachments(const QString& sep) const { return mEmailAttachments.join(sep); }
+ bool emailBcc() const { return mEmailBcc; }
+ const QColor& bgColour() const { return mBgColour; }
+ const QColor& fgColour() const { return mFgColour; }
+ bool defaultFont() const { return mDefaultFont; }
+ const QFont& font() const;
+ int lateCancel() const { return mLateCancel; }
+ bool autoClose() const { return mAutoClose; }
+ bool commandScript() const { return mCommandScript; }
+ bool confirmAck() const { return mConfirmAck; }
+ bool repeatAtLogin() const { return mRepeatAtLogin; }
+ int repeatCount() const { return mRepeatCount; }
+ int repeatInterval() const { return mRepeatInterval; }
+ bool displaying() const { return mDisplaying; }
+ bool beep() const { return mBeep; }
+ bool speak() const { return (mActionType == T_MESSAGE) && mSpeak; }
+ int flags() const;
+#ifdef NDEBUG
+ void dumpDebug() const { }
+#else
+ void dumpDebug() const;
+#endif
+
+ protected:
+ enum Type { T_MESSAGE, T_FILE, T_COMMAND, T_AUDIO, T_EMAIL };
+
+ KAAlarmEventBase() : mRepeatCount(0), mLateCancel(0), mAutoClose(false), mBeep(false), mRepeatAtLogin(false),
+ mDisplaying(false), mEmailBcc(false), mConfirmAck(false) { }
+ KAAlarmEventBase(const KAAlarmEventBase& rhs) { copy(rhs); }
+ KAAlarmEventBase& operator=(const KAAlarmEventBase& rhs) { copy(rhs); return *this; }
+ void copy(const KAAlarmEventBase&);
+ void set(int flags);
+
+ QString mEventID; // UID: KCal::Event unique ID
+ QString mText; // message text, file URL, command, email body [or audio file for KAAlarm]
+ DateTime mNextMainDateTime; // next time to display the alarm, excluding repetitions
+ QColor mBgColour; // background colour of alarm message
+ QColor mFgColour; // foreground colour of alarm message, or invalid for default
+ QFont mFont; // font of alarm message (ignored if mDefaultFont true)
+ uint mEmailFromIdentity;// KMail identity for email 'From' field, or empty
+ EmailAddressList mEmailAddresses; // ATTENDEE: addresses to send email to
+ QString mEmailSubject; // SUMMARY: subject line of email
+ QStringList mEmailAttachments; // ATTACH: email attachment file names
+ float mSoundVolume; // volume for sound file, or < 0 for unspecified
+ float mFadeVolume; // initial volume for sound file, or < 0 for no fade
+ int mFadeSeconds; // fade time for sound file, or 0 if none
+ Type mActionType; // alarm action type
+ int mRepeatCount; // sub-repetition count (excluding the first time)
+ int mRepeatInterval; // sub-repetition interval (minutes)
+ int mNextRepeat; // repetition count of next due sub-repetition
+ int mLateCancel; // how many minutes late will cancel the alarm, or 0 for no cancellation
+ bool mAutoClose; // whether to close the alarm window after the late-cancel period
+ bool mCommandScript; // the command text is a script, not a shell command line
+ bool mBeep; // whether to beep when the alarm is displayed
+ bool mSpeak; // whether to speak the message when the alarm is displayed
+ bool mRepeatSound; // whether to repeat the sound file while the alarm is displayed
+ bool mRepeatAtLogin; // whether to repeat the alarm at every login
+ bool mDisplaying; // whether the alarm is currently being displayed
+ bool mEmailBcc; // blind copy the email to the user
+ bool mConfirmAck; // alarm acknowledgement requires confirmation by user
+ bool mDefaultFont; // use default message font, not mFont
+
+ friend class AlarmData;
+};
+
+
+// KAAlarm corresponds to a single KCal::Alarm instance.
+// A KAEvent may contain multiple KAAlarm's.
+class KAAlarm : public KAAlarmEventBase
+{
+ public:
+ // Define the basic KAAlaem action types
+ enum Action
+ {
+ MESSAGE = T_MESSAGE, // KCal::Alarm::Display type: display a text message
+ FILE = T_FILE, // KCal::Alarm::Display type: display a file (URL given by the alarm text)
+ COMMAND = T_COMMAND, // KCal::Alarm::Procedure type: execute a shell command
+ EMAIL = T_EMAIL, // KCal::Alarm::Email type: send an email
+ AUDIO = T_AUDIO // KCal::Alarm::Audio type: play a sound file
+ };
+ // Define the KAAlarm types.
+ // KAAlarm's of different types may be contained in a KAEvent,
+ // each defining a different component of the overall alarm.
+ enum Type
+ {
+ INVALID_ALARM = 0, // not an alarm
+ MAIN_ALARM = 1, // THE real alarm. Must be the first in the enumeration.
+ // The following values may be used in combination as a bitmask 0x0E
+ REMINDER_ALARM = 0x02, // reminder in advance of main alarm
+ DEFERRED_ALARM = 0x04, // deferred alarm
+ DEFERRED_REMINDER_ALARM = REMINDER_ALARM | DEFERRED_ALARM, // deferred early warning
+ // The following values must be greater than the preceding ones, to
+ // ensure that in ordered processing they are processed afterwards.
+ AT_LOGIN_ALARM = 0x10, // additional repeat-at-login trigger
+ DISPLAYING_ALARM = 0x20, // copy of the alarm currently being displayed
+ // The following values are for internal KAEvent use only
+ AUDIO_ALARM = 0x30, // sound to play when displaying the alarm
+ PRE_ACTION_ALARM = 0x40, // command to execute before displaying the alarm
+ POST_ACTION_ALARM = 0x50 // command to execute after the alarm window is closed
+ };
+ enum SubType
+ {
+ INVALID__ALARM = INVALID_ALARM,
+ MAIN__ALARM = MAIN_ALARM,
+ // The following values may be used in combination as a bitmask 0x0E
+ REMINDER__ALARM = REMINDER_ALARM,
+ TIMED_DEFERRAL_FLAG = 0x08, // deferral has a time; if clear, it is date-only
+ DEFERRED_DATE__ALARM = DEFERRED_ALARM, // deferred alarm - date-only
+ DEFERRED_TIME__ALARM = DEFERRED_ALARM | TIMED_DEFERRAL_FLAG,
+ DEFERRED_REMINDER_DATE__ALARM = REMINDER_ALARM | DEFERRED_ALARM, // deferred early warning (date-only)
+ DEFERRED_REMINDER_TIME__ALARM = REMINDER_ALARM | DEFERRED_ALARM | TIMED_DEFERRAL_FLAG, // deferred early warning (date/time)
+ // The following values must be greater than the preceding ones, to
+ // ensure that in ordered processing they are processed afterwards.
+ AT_LOGIN__ALARM = AT_LOGIN_ALARM,
+ DISPLAYING__ALARM = DISPLAYING_ALARM,
+ // The following values are for internal KAEvent use only
+ AUDIO__ALARM = AUDIO_ALARM,
+ PRE_ACTION__ALARM = PRE_ACTION_ALARM,
+ POST_ACTION__ALARM = POST_ACTION_ALARM
+ };
+
+ KAAlarm() : mType(INVALID__ALARM), mDeferred(false) { }
+ KAAlarm(const KAAlarm&);
+ ~KAAlarm() { }
+ Action action() const { return (Action)mActionType; }
+ bool valid() const { return mType != INVALID__ALARM; }
+ Type type() const { return static_cast<Type>(mType & ~TIMED_DEFERRAL_FLAG); }
+ SubType subType() const { return mType; }
+ const QString& eventID() const { return mEventID; }
+ DateTime dateTime(bool withRepeats = false) const
+ { return (withRepeats && mNextRepeat && mRepeatInterval)
+ ? mNextMainDateTime.addSecs(mNextRepeat * mRepeatInterval * 60) : mNextMainDateTime; }
+ QDate date() const { return mNextMainDateTime.date(); }
+ QTime time() const { return mNextMainDateTime.time(); }
+ QString audioFile() const { return (mActionType == T_AUDIO) && !mBeep ? mText : QString::null; }
+ float soundVolume() const { return (mActionType == T_AUDIO) && !mBeep && !mText.isEmpty() ? mSoundVolume : -1; }
+ float fadeVolume() const { return (mActionType == T_AUDIO) && mSoundVolume >= 0 && mFadeSeconds && !mBeep && !mText.isEmpty() ? mFadeVolume : -1; }
+ int fadeSeconds() const { return (mActionType == T_AUDIO) && mSoundVolume >= 0 && mFadeVolume >= 0 && !mBeep && !mText.isEmpty() ? mFadeSeconds : 0; }
+ bool repeatSound() const { return (mActionType == T_AUDIO) && mRepeatSound && !mBeep && !mText.isEmpty(); }
+ bool reminder() const { return mType == REMINDER__ALARM; }
+ bool deferred() const { return mDeferred; }
+ void setTime(const DateTime& dt) { mNextMainDateTime = dt; }
+ void setTime(const QDateTime& dt) { mNextMainDateTime = dt; }
+ int flags() const;
+#ifdef NDEBUG
+ void dumpDebug() const { }
+ static const char* debugType(Type) { return ""; }
+#else
+ void dumpDebug() const;
+ static const char* debugType(Type);
+#endif
+
+ private:
+ SubType mType; // alarm type
+ bool mRecurs; // there is a recurrence rule for the alarm
+ bool mDeferred; // whether the alarm is an extra deferred/deferred-reminder alarm
+
+ friend class KAEvent;
+};
+
+
+/** KAEvent corresponds to a KCal::Event instance */
+class KAEvent : public KAAlarmEventBase
+{
+ public:
+ enum // flags for use in DCOP calls, etc.
+ {
+#ifdef OLD_DCOP
+ // *** DON'T CHANGE THESE VALUES ***
+ // because they are part of KAlarm's external DCOP interface.
+ // (But it's alright to add new values.)
+ LATE_CANCEL = 0x01, // cancel alarm if not triggered within a minute of its scheduled time
+#endif
+ BEEP = 0x02, // sound audible beep when alarm is displayed
+ REPEAT_AT_LOGIN = 0x04, // repeat alarm at every login
+ ANY_TIME = 0x08, // only a date is specified for the alarm, not a time
+ CONFIRM_ACK = 0x10, // closing the alarm message window requires confirmation prompt
+ EMAIL_BCC = 0x20, // blind copy the email to the user
+ DEFAULT_FONT = 0x40, // use default alarm message font
+ REPEAT_SOUND = 0x80, // repeat sound file while alarm is displayed
+ DISABLED = 0x100, // alarm is currently disabled
+ AUTO_CLOSE = 0x200, // auto-close alarm window after late-cancel period
+ SCRIPT = 0x400, // command is a script, not a shell command line
+ EXEC_IN_XTERM = 0x800, // execute command in terminal window
+ SPEAK = 0x1000, // speak the message when the alarm is displayed
+ COPY_KORGANIZER = 0x2000, // KOrganizer should hold a copy of the event
+#ifdef OLD_DCOP
+ // The following are read-only internal values, and may be changed
+#else
+ // The following are read-only internal values
+#endif
+ REMINDER = 0x10000,
+ DEFERRAL = 0x20000,
+ TIMED_FLAG = 0x40000,
+ DATE_DEFERRAL = DEFERRAL,
+ TIME_DEFERRAL = DEFERRAL | TIMED_FLAG,
+ DISPLAYING_ = 0x80000,
+ READ_ONLY_FLAGS = 0xF0000 // mask for all read-only internal values
+ };
+ /** The category of an event, indicated by the middle part of its UID. */
+ enum Status
+ {
+ ACTIVE, // the event is currently active
+ EXPIRED, // the event has expired
+ DISPLAYING, // the event is currently being displayed
+ TEMPLATE, // the event is an alarm template
+ KORGANIZER // the event is a copy of a KAlarm event, held by KOrganizer
+ };
+ enum Action
+ {
+ MESSAGE = T_MESSAGE,
+ FILE = T_FILE,
+ COMMAND = T_COMMAND,
+ EMAIL = T_EMAIL
+ };
+ enum OccurType // what type of occurrence is due
+ {
+ NO_OCCURRENCE = 0, // no occurrence is due
+ FIRST_OR_ONLY_OCCURRENCE = 0x01, // the first occurrence (takes precedence over LAST_RECURRENCE)
+ RECURRENCE_DATE = 0x02, // a recurrence with only a date, not a time
+ RECURRENCE_DATE_TIME = 0x03, // a recurrence with a date and time
+ LAST_RECURRENCE = 0x04, // the last recurrence
+ OCCURRENCE_REPEAT = 0x10, // (bitmask for a repetition of an occurrence)
+ FIRST_OR_ONLY_OCCURRENCE_REPEAT = OCCURRENCE_REPEAT | FIRST_OR_ONLY_OCCURRENCE, // a repetition of the first occurrence
+ RECURRENCE_DATE_REPEAT = OCCURRENCE_REPEAT | RECURRENCE_DATE, // a repetition of a date-only recurrence
+ RECURRENCE_DATE_TIME_REPEAT = OCCURRENCE_REPEAT | RECURRENCE_DATE_TIME, // a repetition of a date/time recurrence
+ LAST_RECURRENCE_REPEAT = OCCURRENCE_REPEAT | LAST_RECURRENCE // a repetition of the last recurrence
+ };
+ enum OccurOption // options for nextOccurrence()
+ {
+ IGNORE_REPETITION, // check for recurrences only, ignore repetitions
+ RETURN_REPETITION, // return repetition if it's the next occurrence
+ ALLOW_FOR_REPETITION // check for repetition being the next occurrence, but return recurrence
+ };
+ enum DeferLimitType // what type of occurrence currently limits a deferral
+ {
+ LIMIT_NONE,
+ LIMIT_MAIN,
+ LIMIT_RECURRENCE,
+ LIMIT_REPETITION,
+ LIMIT_REMINDER
+ };
+
+ KAEvent() : mRevision(0), mRecurrence(0), mAlarmCount(0) { }
+ KAEvent(const QDateTime& dt, const QString& message, const QColor& bg, const QColor& fg, const QFont& f, Action action, int lateCancel, int flags)
+ : mRecurrence(0) { set(dt, message, bg, fg, f, action, lateCancel, flags); }
+ explicit KAEvent(const KCal::Event& e) : mRecurrence(0) { set(e); }
+ KAEvent(const KAEvent& e) : KAAlarmEventBase(e), mRecurrence(0) { copy(e); }
+ ~KAEvent() { delete mRecurrence; }
+ KAEvent& operator=(const KAEvent& e) { if (&e != this) copy(e); return *this; }
+ void set(const KCal::Event&);
+ void set(const QDateTime&, const QString& message, const QColor& bg, const QColor& fg, const QFont&, Action, int lateCancel, int flags);
+ void setEmail(uint from, const EmailAddressList&, const QString& subject, const QStringList& attachments);
+ void setAudioFile(const QString& filename, float volume, float fadeVolume, int fadeSeconds);
+ void setTemplate(const QString& name, int afterTime = -1) { mTemplateName = name; mTemplateAfterTime = afterTime; mUpdated = true; }
+ void setActions(const QString& pre, const QString& post) { mPreAction = pre; mPostAction = post; mUpdated = true; }
+ OccurType setNextOccurrence(const QDateTime& preDateTime);
+ void setFirstRecurrence();
+ void setEventID(const QString& id) { mEventID = id; mUpdated = true; }
+ void setDate(const QDate& d) { mNextMainDateTime.set(d); mUpdated = true; }
+ void setTime(const QDateTime& dt) { mNextMainDateTime.set(dt); mUpdated = true; }
+ void setSaveDateTime(const QDateTime& dt) { mSaveDateTime = dt; mUpdated = true; }
+ void setLateCancel(int lc) { mLateCancel = lc; mUpdated = true; }
+ void setAutoClose(bool ac) { mAutoClose = ac; mUpdated = true; }
+ void setRepeatAtLogin(bool rl) { mRepeatAtLogin = rl; mUpdated = true; }
+ void setUid(Status s) { mEventID = uid(mEventID, s); mUpdated = true; }
+ void setKMailSerialNumber(unsigned long n) { mKMailSerialNumber = n; }
+ void setLogFile(const QString& logfile);
+ void setReminder(int minutes, bool onceOnly);
+ bool defer(const DateTime&, bool reminder, bool adjustRecurrence = false);
+ void cancelDefer();
+ void cancelCancelledDeferral();
+ void setDeferDefaultMinutes(int minutes) { mDeferDefaultMinutes = minutes; mUpdated = true; }
+ bool setDisplaying(const KAEvent&, KAAlarm::Type, const QDateTime&);
+ void reinstateFromDisplaying(const KAEvent& dispEvent);
+ void setArchive() { mArchive = true; mUpdated = true; }
+ void setEnabled(bool enable) { mEnabled = enable; mUpdated = true; }
+ void setUpdated() { mUpdated = true; }
+ void clearUpdated() const { mUpdated = false; }
+ void removeExpiredAlarm(KAAlarm::Type);
+ void incrementRevision() { ++mRevision; mUpdated = true; }
+
+ KCal::Event* event() const; // convert to new Event
+ bool isTemplate() const { return !mTemplateName.isEmpty(); }
+ const QString& templateName() const { return mTemplateName; }
+ bool usingDefaultTime() const { return mTemplateAfterTime == 0; }
+ int templateAfterTime() const { return mTemplateAfterTime; }
+ KAAlarm alarm(KAAlarm::Type) const;
+ KAAlarm firstAlarm() const;
+ KAAlarm nextAlarm(const KAAlarm& al) const { return nextAlarm(al.type()); }
+ KAAlarm nextAlarm(KAAlarm::Type) const;
+ KAAlarm convertDisplayingAlarm() const;
+ bool updateKCalEvent(KCal::Event&, bool checkUid = true, bool original = false, bool cancelCancelledDefer = false) const;
+ Action action() const { return (Action)mActionType; }
+ bool displayAction() const { return mActionType == T_MESSAGE || mActionType == T_FILE; }
+ const QString& id() const { return mEventID; }
+ bool valid() const { return mAlarmCount && (mAlarmCount != 1 || !mRepeatAtLogin); }
+ int alarmCount() const { return mAlarmCount; }
+ const DateTime& startDateTime() const { return mStartDateTime; }
+ DateTime mainDateTime(bool withRepeats = false) const
+ { return (withRepeats && mNextRepeat && mRepeatInterval)
+ ? mNextMainDateTime.addSecs(mNextRepeat * mRepeatInterval * 60) : mNextMainDateTime; }
+ QDate mainDate() const { return mNextMainDateTime.date(); }
+ QTime mainTime() const { return mNextMainDateTime.time(); }
+ DateTime mainEndRepeatTime() const { return (mRepeatCount > 0 && mRepeatInterval)
+ ? mNextMainDateTime.addSecs(mRepeatCount * mRepeatInterval * 60) : mNextMainDateTime; }
+ int reminder() const { return mReminderMinutes; }
+ bool reminderOnceOnly() const { return mReminderOnceOnly; }
+ bool reminderDeferral() const { return mDeferral == REMINDER_DEFERRAL; }
+ int reminderArchived() const { return mArchiveReminderMinutes; }
+ DateTime deferDateTime() const { return mDeferralTime; }
+ DateTime deferralLimit(DeferLimitType* = 0) const;
+ int deferDefaultMinutes() const { return mDeferDefaultMinutes; }
+ DateTime displayDateTime() const;
+ const QString& messageFileOrCommand() const { return mText; }
+ QString logFile() const { return mLogFile; }
+ bool commandXterm() const { return mCommandXterm; }
+ unsigned long kmailSerialNumber() const { return mKMailSerialNumber; }
+ bool copyToKOrganizer() const { return mCopyToKOrganizer; }
+ const QString& audioFile() const { return mAudioFile; }
+ float soundVolume() const { return !mAudioFile.isEmpty() ? mSoundVolume : -1; }
+ float fadeVolume() const { return !mAudioFile.isEmpty() && mSoundVolume >= 0 && mFadeSeconds ? mFadeVolume : -1; }
+ int fadeSeconds() const { return !mAudioFile.isEmpty() && mSoundVolume >= 0 && mFadeVolume >= 0 ? mFadeSeconds : 0; }
+ bool repeatSound() const { return mRepeatSound && !mAudioFile.isEmpty(); }
+ const QString& preAction() const { return mPreAction; }
+ const QString& postAction() const { return mPostAction; }
+ bool recurs() const { return checkRecur() != KARecurrence::NO_RECUR; }
+ KARecurrence::Type recurType() const { return checkRecur(); }
+ KARecurrence* recurrence() const { return mRecurrence; }
+ int recurInterval() const; // recurrence period in units of the recurrence period type (minutes, days, etc)
+ int longestRecurrenceInterval() const { return mRecurrence ? mRecurrence->longestInterval() : 0; }
+ QString recurrenceText(bool brief = false) const;
+ QString repetitionText(bool brief = false) const;
+ bool occursAfter(const QDateTime& preDateTime, bool includeRepetitions) const;
+ OccurType nextOccurrence(const QDateTime& preDateTime, DateTime& result, OccurOption = IGNORE_REPETITION) const;
+ OccurType previousOccurrence(const QDateTime& afterDateTime, DateTime& result, bool includeRepetitions = false) const;
+ int flags() const;
+ bool deferred() const { return mDeferral > 0; }
+ bool toBeArchived() const { return mArchive; }
+ bool enabled() const { return mEnabled; }
+ bool updated() const { return mUpdated; }
+ bool mainExpired() const { return mMainExpired; }
+ bool expired() const { return mDisplaying && mMainExpired || uidStatus(mEventID) == EXPIRED; }
+ Status uidStatus() const { return uidStatus(mEventID); }
+ static Status uidStatus(const QString& uid);
+ static QString uid(const QString& id, Status);
+ static KAEvent findTemplateName(AlarmCalendar&, const QString& name);
+
+ struct MonthPos
+ {
+ MonthPos() : days(7) { }
+ int weeknum; // week in month, or < 0 to count from end of month
+ QBitArray days; // days in week
+ };
+ bool setRepetition(int interval, int count);
+ void setNoRecur() { clearRecur(); }
+ void setRecurrence(const KARecurrence&);
+ bool setRecurMinutely(int freq, int count, const QDateTime& end);
+ bool setRecurDaily(int freq, const QBitArray& days, int count, const QDate& end);
+ bool setRecurWeekly(int freq, const QBitArray& days, int count, const QDate& end);
+ bool setRecurMonthlyByDate(int freq, const QValueList<int>& days, int count, const QDate& end);
+ bool setRecurMonthlyByPos(int freq, const QValueList<MonthPos>& pos, int count, const QDate& end);
+ bool setRecurAnnualByDate(int freq, const QValueList<int>& months, int day, KARecurrence::Feb29Type, int count, const QDate& end);
+ bool setRecurAnnualByPos(int freq, const QValueList<MonthPos>& pos, const QValueList<int>& months, int count, const QDate& end);
+// static QValueList<MonthPos> convRecurPos(const QValueList<KCal::RecurrenceRule::WDayPos>&);
+#ifdef NDEBUG
+ void dumpDebug() const { }
+#else
+ void dumpDebug() const;
+#endif
+ static int calVersion();
+ static QString calVersionString();
+ static bool adjustStartOfDay(const KCal::Event::List&);
+ static void convertKCalEvents(KCal::Calendar&, int version, bool adjustSummerTime);
+ static void convertRepetitions(KCal::CalendarLocal&);
+
+ private:
+ enum DeferType {
+ CANCEL_DEFERRAL = -1, // there was a deferred alarm, but it has been cancelled
+ NO_DEFERRAL = 0, // there is no deferred alarm
+ NORMAL_DEFERRAL, // the main alarm, a recurrence or a repeat is deferred
+ REMINDER_DEFERRAL // a reminder alarm is deferred
+ };
+
+ void copy(const KAEvent&);
+ bool setRecur(KCal::RecurrenceRule::PeriodType, int freq, int count, const QDateTime& end, KARecurrence::Feb29Type = KARecurrence::FEB29_FEB29);
+ void clearRecur();
+ KARecurrence::Type checkRecur() const;
+ void checkRepetition() const;
+ OccurType nextRecurrence(const QDateTime& preDateTime, DateTime& result) const;
+ OccurType previousRecurrence(const QDateTime& afterDateTime, DateTime& result) const;
+ static bool convertRepetition(KCal::Event*);
+ KCal::Alarm* initKCalAlarm(KCal::Event&, const DateTime&, const QStringList& types, KAAlarm::Type = KAAlarm::INVALID_ALARM) const;
+ KCal::Alarm* initKCalAlarm(KCal::Event&, int startOffsetSecs, const QStringList& types, KAAlarm::Type = KAAlarm::INVALID_ALARM) const;
+ static DateTime readDateTime(const KCal::Event&, bool dateOnly, DateTime& start);
+ static void readAlarms(const KCal::Event&, void* alarmMap);
+ static void readAlarm(const KCal::Alarm&, AlarmData&);
+ inline void set_deferral(DeferType);
+ inline void set_reminder(int minutes);
+ inline void set_archiveReminder();
+
+ QString mTemplateName; // alarm template's name, or null if normal event
+ QString mAudioFile; // ATTACH: audio file to play
+ QString mPreAction; // command to execute before alarm is displayed
+ QString mPostAction; // command to execute after alarm window is closed
+ DateTime mStartDateTime; // DTSTART and DTEND: start and end time for event
+ QDateTime mSaveDateTime; // CREATED: date event was created, or saved in expired calendar
+ QDateTime mAtLoginDateTime; // repeat-at-login time
+ DateTime mDeferralTime; // extra time to trigger alarm (if alarm or reminder deferred)
+ DateTime mDisplayingTime; // date/time shown in the alarm currently being displayed
+ int mDisplayingFlags; // type of alarm which is currently being displayed
+ int mReminderMinutes; // how long in advance reminder is to be, or 0 if none
+ int mArchiveReminderMinutes; // original reminder period if now expired, or 0 if none
+ int mDeferDefaultMinutes; // default number of minutes for deferral dialogue, or 0 to select time control
+ int mRevision; // SEQUENCE: revision number of the original alarm, or 0
+ KARecurrence* mRecurrence; // RECUR: recurrence specification, or 0 if none
+ int mAlarmCount; // number of alarms: count of !mMainExpired, mRepeatAtLogin, mDeferral, mReminderMinutes, mDisplaying
+ DeferType mDeferral; // whether the alarm is an extra deferred/deferred-reminder alarm
+ unsigned long mKMailSerialNumber;// if email text, message's KMail serial number
+ int mTemplateAfterTime;// time not specified: use n minutes after default time, or -1 (applies to templates only)
+ QString mLogFile; // alarm output is to be logged to this URL
+ bool mCommandXterm; // command alarm is to be executed in a terminal window
+ bool mCopyToKOrganizer; // KOrganizer should hold a copy of the event
+ bool mReminderOnceOnly; // the reminder is output only for the first recurrence
+ bool mMainExpired; // main alarm has expired (in which case a deferral alarm will exist)
+ bool mArchiveRepeatAtLogin; // if now expired, original event was repeat-at-login
+ bool mArchive; // event has triggered in the past, so archive it when closed
+ bool mEnabled; // false if event is disabled
+ mutable bool mUpdated; // event has been updated but not written to calendar file
+};
+
+#endif // KALARMEVENT_H