kalarm

alarmevent.h
Go to the documentation of this file.
1/*
2 * alarmevent.h - represents calendar alarms and events
3 * Program: kalarm
4 * Copyright © 2001-2008 by David Jarvie <djarvie@kde.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 */
20
21#ifndef KALARMEVENT_H
22#define KALARMEVENT_H
23
26#include <tqcolor.h>
27#include <tqfont.h>
28
29#include <libkcal/person.h>
30#include <libkcal/event.h>
31namespace KCal {
32 class Calendar;
33 class CalendarLocal;
34}
35
36#include "datetime.h"
37#include "karecurrence.h"
38
39class AlarmCalendar;
40class KARecurrence;
41struct AlarmData;
42
43
44typedef KCal::Person EmailAddress;
45class EmailAddressList : public TQValueList<KCal::Person>
46{
47 public:
48 EmailAddressList() : TQValueList<KCal::Person>() { }
49 EmailAddressList(const TQValueList<KCal::Person>& list) { operator=(list); }
50 EmailAddressList& operator=(const TQValueList<KCal::Person>&);
51 TQString join(const TQString& separator) const;
52};
53
54
55// Base class containing data common to KAAlarm and KAEvent
56class KAAlarmEventBase
57{
58 public:
59 ~KAAlarmEventBase() { }
60 const TQString& cleanText() const { return mText; }
61 TQString message() const { return (mActionType == T_MESSAGE || mActionType == T_EMAIL) ? mText : TQString(); }
62 TQString fileName() const { return (mActionType == T_FILE) ? mText : TQString(); }
63 TQString command() const { return (mActionType == T_COMMAND) ? mText : TQString(); }
64 uint emailFromId() const { return mEmailFromIdentity; }
65 const EmailAddressList& emailAddresses() const { return mEmailAddresses; }
66 TQString emailAddresses(const TQString& sep) const { return mEmailAddresses.join(sep); }
67 const TQString& emailSubject() const { return mEmailSubject; }
68 const TQStringList& emailAttachments() const { return mEmailAttachments; }
69 TQString emailAttachments(const TQString& sep) const { return mEmailAttachments.join(sep); }
70 bool emailBcc() const { return mEmailBcc; }
71 const TQColor& bgColour() const { return mBgColour; }
72 const TQColor& fgColour() const { return mFgColour; }
73 bool defaultFont() const { return mDefaultFont; }
74 const TQFont& font() const;
75 int lateCancel() const { return mLateCancel; }
76 bool autoClose() const { return mAutoClose; }
77 bool commandScript() const { return mCommandScript; }
78 bool confirmAck() const { return mConfirmAck; }
79 bool repeatAtLogin() const { return mRepeatAtLogin; }
80 int repeatCount() const { return mRepeatCount; }
81 int repeatInterval() const { return mRepeatInterval; }
82 bool displaying() const { return mDisplaying; }
83 bool beep() const { return mBeep; }
84 bool speak() const { return (mActionType == T_MESSAGE) && mSpeak; }
85 int flags() const;
86#ifdef NDEBUG
87 void dumpDebug() const { }
88#else
89 void dumpDebug() const;
90#endif
91
92 protected:
93 enum Type { T_MESSAGE, T_FILE, T_COMMAND, T_AUDIO, T_EMAIL };
94
95 KAAlarmEventBase() : mRepeatCount(0), mLateCancel(0), mAutoClose(false), mBeep(false), mRepeatAtLogin(false),
96 mDisplaying(false), mEmailBcc(false), mConfirmAck(false) { }
97 KAAlarmEventBase(const KAAlarmEventBase& rhs) { copy(rhs); }
98 KAAlarmEventBase& operator=(const KAAlarmEventBase& rhs) { copy(rhs); return *this; }
99 void copy(const KAAlarmEventBase&);
100 void set(int flags);
101
102 TQString mEventID; // UID: KCal::Event unique ID
103 TQString mText; // message text, file URL, command, email body [or audio file for KAAlarm]
104 DateTime mNextMainDateTime; // next time to display the alarm, excluding repetitions
105 TQColor mBgColour; // background colour of alarm message
106 TQColor mFgColour; // foreground colour of alarm message, or invalid for default
107 TQFont mFont; // font of alarm message (ignored if mDefaultFont true)
108 uint mEmailFromIdentity;// KMail identity for email 'From' field, or empty
109 EmailAddressList mEmailAddresses; // ATTENDEE: addresses to send email to
110 TQString mEmailSubject; // SUMMARY: subject line of email
111 TQStringList mEmailAttachments; // ATTACH: email attachment file names
112 float mSoundVolume; // volume for sound file, or < 0 for unspecified
113 float mFadeVolume; // initial volume for sound file, or < 0 for no fade
114 int mFadeSeconds; // fade time for sound file, or 0 if none
115 Type mActionType; // alarm action type
116 int mRepeatCount; // sub-repetition count (excluding the first time)
117 int mRepeatInterval; // sub-repetition interval (minutes)
118 int mNextRepeat; // repetition count of next due sub-repetition
119 int mLateCancel; // how many minutes late will cancel the alarm, or 0 for no cancellation
120 bool mAutoClose; // whether to close the alarm window after the late-cancel period
121 bool mCommandScript; // the command text is a script, not a shell command line
122 bool mBeep; // whether to beep when the alarm is displayed
123 bool mSpeak; // whether to speak the message when the alarm is displayed
124 bool mRepeatSound; // whether to repeat the sound file while the alarm is displayed
125 bool mRepeatAtLogin; // whether to repeat the alarm at every login
126 bool mDisplaying; // whether the alarm is currently being displayed
127 bool mEmailBcc; // blind copy the email to the user
128 bool mConfirmAck; // alarm acknowledgement requires confirmation by user
129 bool mDefaultFont; // use default message font, not mFont
130
131 friend class AlarmData;
132};
133
134
135// KAAlarm corresponds to a single KCal::Alarm instance.
136// A KAEvent may contain multiple KAAlarm's.
137class KAAlarm : public KAAlarmEventBase
138{
139 public:
140 // Define the basic KAAlaem action types
141 enum Action
142 {
143 MESSAGE = T_MESSAGE, // KCal::Alarm::Display type: display a text message
144 FILE = T_FILE, // KCal::Alarm::Display type: display a file (URL given by the alarm text)
145 COMMAND = T_COMMAND, // KCal::Alarm::Procedure type: execute a shell command
146 EMAIL = T_EMAIL, // KCal::Alarm::Email type: send an email
147 AUDIO = T_AUDIO // KCal::Alarm::Audio type: play a sound file
148 };
149 // Define the KAAlarm types.
150 // KAAlarm's of different types may be contained in a KAEvent,
151 // each defining a different component of the overall alarm.
152 enum Type
153 {
154 INVALID_ALARM = 0, // not an alarm
155 MAIN_ALARM = 1, // THE real alarm. Must be the first in the enumeration.
156 // The following values may be used in combination as a bimask 0x0E
157 REMINDER_ALARM = 0x02, // reminder in advance of main alarm
158 DEFERRED_ALARM = 0x04, // deferred alarm
159 DEFERRED_REMINDER_ALARM = REMINDER_ALARM | DEFERRED_ALARM, // deferred early warning
160 // The following values must be greater than the preceding ones, to
161 // ensure that in ordered processing they are processed afterwards.
162 AT_LOGIN_ALARM = 0x10, // additional repeat-at-login trigger
163 DISPLAYING_ALARM = 0x20, // copy of the alarm currently being displayed
164 // The following values are for internal KAEvent use only
165 AUDIO_ALARM = 0x30, // sound to play when displaying the alarm
166 PRE_ACTION_ALARM = 0x40, // command to execute before displaying the alarm
167 POST_ACTION_ALARM = 0x50 // command to execute after the alarm window is closed
168 };
169 enum SubType
170 {
171 INVALID__ALARM = INVALID_ALARM,
172 MAIN__ALARM = MAIN_ALARM,
173 // The following values may be used in combination as a bimask 0x0E
174 REMINDER__ALARM = REMINDER_ALARM,
175 TIMED_DEFERRAL_FLAG = 0x08, // deferral has a time; if clear, it is date-only
176 DEFERRED_DATE__ALARM = DEFERRED_ALARM, // deferred alarm - date-only
177 DEFERRED_TIME__ALARM = DEFERRED_ALARM | TIMED_DEFERRAL_FLAG,
178 DEFERRED_REMINDER_DATE__ALARM = REMINDER_ALARM | DEFERRED_ALARM, // deferred early warning (date-only)
179 DEFERRED_REMINDER_TIME__ALARM = REMINDER_ALARM | DEFERRED_ALARM | TIMED_DEFERRAL_FLAG, // deferred early warning (date/time)
180 // The following values must be greater than the preceding ones, to
181 // ensure that in ordered processing they are processed afterwards.
182 AT_LOGIN__ALARM = AT_LOGIN_ALARM,
183 DISPLAYING__ALARM = DISPLAYING_ALARM,
184 // The following values are for internal KAEvent use only
185 AUDIO__ALARM = AUDIO_ALARM,
186 PRE_ACTION__ALARM = PRE_ACTION_ALARM,
187 POST_ACTION__ALARM = POST_ACTION_ALARM
188 };
189
190 KAAlarm() : mType(INVALID__ALARM), mDeferred(false) { }
191 KAAlarm(const KAAlarm&);
192 ~KAAlarm() { }
193 Action action() const { return (Action)mActionType; }
194 bool valid() const { return mType != INVALID__ALARM; }
195 Type type() const { return static_cast<Type>(mType & ~TIMED_DEFERRAL_FLAG); }
196 SubType subType() const { return mType; }
197 const TQString& eventID() const { return mEventID; }
198 DateTime dateTime(bool withRepeats = false) const
199 { return (withRepeats && mNextRepeat && mRepeatInterval)
200 ? mNextMainDateTime.addSecs(mNextRepeat * mRepeatInterval * 60) : mNextMainDateTime; }
201 TQDate date() const { return mNextMainDateTime.date(); }
202 TQTime time() const { return mNextMainDateTime.time(); }
203 TQString audioFile() const { return (mActionType == T_AUDIO) && !mBeep ? mText : TQString(); }
204 float soundVolume() const { return (mActionType == T_AUDIO) && !mBeep && !mText.isEmpty() ? mSoundVolume : -1; }
205 float fadeVolume() const { return (mActionType == T_AUDIO) && mSoundVolume >= 0 && mFadeSeconds && !mBeep && !mText.isEmpty() ? mFadeVolume : -1; }
206 int fadeSeconds() const { return (mActionType == T_AUDIO) && mSoundVolume >= 0 && mFadeVolume >= 0 && !mBeep && !mText.isEmpty() ? mFadeSeconds : 0; }
207 bool repeatSound() const { return (mActionType == T_AUDIO) && mRepeatSound && !mBeep && !mText.isEmpty(); }
208 bool reminder() const { return mType == REMINDER__ALARM; }
209 bool deferred() const { return mDeferred; }
210 void setTime(const DateTime& dt) { mNextMainDateTime = dt; }
211 void setTime(const TQDateTime& dt) { mNextMainDateTime = dt; }
212 int flags() const;
213#ifdef NDEBUG
214 void dumpDebug() const { }
215 static const char* debugType(Type) { return ""; }
216#else
217 void dumpDebug() const;
218 static const char* debugType(Type);
219#endif
220
221 private:
222 SubType mType; // alarm type
223 bool mRecurs; // there is a recurrence rule for the alarm
224 bool mDeferred; // whether the alarm is an extra deferred/deferred-reminder alarm
225
226 friend class KAEvent;
227};
228
229
231class KAEvent : public KAAlarmEventBase
232{
233 public:
234 enum // flags for use in DCOP calls, etc.
235 {
236#ifdef OLD_DCOP
237 // *** DON'T CHANGE THESE VALUES ***
238 // because they are part of KAlarm's external DCOP interface.
239 // (But it's alright to add new values.)
240 LATE_CANCEL = 0x01, // cancel alarm if not triggered within a minute of its scheduled time
241#endif
242 BEEP = 0x02, // sound audible beep when alarm is displayed
243 REPEAT_AT_LOGIN = 0x04, // repeat alarm at every login
244 ANY_TIME = 0x08, // only a date is specified for the alarm, not a time
245 CONFIRM_ACK = 0x10, // closing the alarm message window requires confirmation prompt
246 EMAIL_BCC = 0x20, // blind copy the email to the user
247 DEFAULT_FONT = 0x40, // use default alarm message font
248 REPEAT_SOUND = 0x80, // repeat sound file while alarm is displayed
249 DISABLED = 0x100, // alarm is currently disabled
250 AUTO_CLOSE = 0x200, // auto-close alarm window after late-cancel period
251 SCRIPT = 0x400, // command is a script, not a shell command line
252 EXEC_IN_XTERM = 0x800, // execute command in terminal window
253 SPEAK = 0x1000, // speak the message when the alarm is displayed
254 COPY_KORGANIZER = 0x2000, // KOrganizer should hold a copy of the event
255#ifdef OLD_DCOP
256 // The following are read-only internal values, and may be changed
257#else
258 // The following are read-only internal values
259#endif
260 REMINDER = 0x10000,
261 DEFERRAL = 0x20000,
262 TIMED_FLAG = 0x40000,
263 DATE_DEFERRAL = DEFERRAL,
264 TIME_DEFERRAL = DEFERRAL | TIMED_FLAG,
265 DISPLAYING_ = 0x80000,
266 READ_ONLY_FLAGS = 0xF0000 // mask for all read-only internal values
267 };
269 enum Status
270 {
271 ACTIVE, // the event is currently active
272 EXPIRED, // the event has expired
273 DISPLAYING, // the event is currently being displayed
274 TEMPLATE, // the event is an alarm template
275 KORGANIZER // the event is a copy of a KAlarm event, held by KOrganizer
276 };
277 enum Action
278 {
279 MESSAGE = T_MESSAGE,
280 FILE = T_FILE,
281 COMMAND = T_COMMAND,
282 EMAIL = T_EMAIL
283 };
284 enum OccurType // what type of occurrence is due
285 {
286 NO_OCCURRENCE = 0, // no occurrence is due
287 FIRST_OR_ONLY_OCCURRENCE = 0x01, // the first occurrence (takes precedence over LAST_RECURRENCE)
288 RECURRENCE_DATE = 0x02, // a recurrence with only a date, not a time
289 RECURRENCE_DATE_TIME = 0x03, // a recurrence with a date and time
290 LAST_RECURRENCE = 0x04, // the last recurrence
291 OCCURRENCE_REPEAT = 0x10, // (bimask for a repetition of an occurrence)
292 FIRST_OR_ONLY_OCCURRENCE_REPEAT = OCCURRENCE_REPEAT | FIRST_OR_ONLY_OCCURRENCE, // a repetition of the first occurrence
293 RECURRENCE_DATE_REPEAT = OCCURRENCE_REPEAT | RECURRENCE_DATE, // a repetition of a date-only recurrence
294 RECURRENCE_DATE_TIME_REPEAT = OCCURRENCE_REPEAT | RECURRENCE_DATE_TIME, // a repetition of a date/time recurrence
295 LAST_RECURRENCE_REPEAT = OCCURRENCE_REPEAT | LAST_RECURRENCE // a repetition of the last recurrence
296 };
297 enum OccurOption // options for nextOccurrence()
298 {
299 IGNORE_REPETITION, // check for recurrences only, ignore repetitions
300 RETURN_REPETITION, // return repetition if it's the next occurrence
301 ALLOW_FOR_REPETITION // check for repetition being the next occurrence, but return recurrence
302 };
303 enum DeferLimitType // what type of occurrence currently limits a deferral
304 {
305 LIMIT_NONE,
306 LIMIT_MAIN,
307 LIMIT_RECURRENCE,
308 LIMIT_REPETITION,
309 LIMIT_REMINDER
310 };
311
312 KAEvent() : mRevision(0), mRecurrence(0), mAlarmCount(0) { }
313 KAEvent(const TQDateTime& dt, const TQString& message, const TQColor& bg, const TQColor& fg, const TQFont& f, Action action, int lateCancel, int flags)
314 : mRecurrence(0) { set(dt, message, bg, fg, f, action, lateCancel, flags); }
315 explicit KAEvent(const KCal::Event& e) : mRecurrence(0) { set(e); }
316 KAEvent(const KAEvent& e) : KAAlarmEventBase(e), mRecurrence(0) { copy(e); }
317 ~KAEvent() { delete mRecurrence; }
318 KAEvent& operator=(const KAEvent& e) { if (&e != this) copy(e); return *this; }
319 void set(const KCal::Event&);
320 void set(const TQDateTime&, const TQString& message, const TQColor& bg, const TQColor& fg, const TQFont&, Action, int lateCancel, int flags);
321 void setEmail(uint from, const EmailAddressList&, const TQString& subject, const TQStringList& attachments);
322 void setAudioFile(const TQString& filename, float volume, float fadeVolume, int fadeSeconds);
323 void setTemplate(const TQString& name, int afterTime = -1) { mTemplateName = name; mTemplateAfterTime = afterTime; mUpdated = true; }
324 void setActions(const TQString& pre, const TQString& post) { mPreAction = pre; mPostAction = post; mUpdated = true; }
325 OccurType setNextOccurrence(const TQDateTime& preDateTime);
326 void setFirstRecurrence();
327 void setEventID(const TQString& id) { mEventID = id; mUpdated = true; }
328 void setDate(const TQDate& d) { mNextMainDateTime.set(d); mUpdated = true; }
329 void setTime(const TQDateTime& dt) { mNextMainDateTime.set(dt); mUpdated = true; }
330 void setSaveDateTime(const TQDateTime& dt) { mSaveDateTime = dt; mUpdated = true; }
331 void setLateCancel(int lc) { mLateCancel = lc; mUpdated = true; }
332 void setAutoClose(bool ac) { mAutoClose = ac; mUpdated = true; }
333 void setRepeatAtLogin(bool rl) { mRepeatAtLogin = rl; mUpdated = true; }
334 void setUid(Status s) { mEventID = uid(mEventID, s); mUpdated = true; }
335 void setKMailSerialNumber(unsigned long n) { mKMailSerialNumber = n; }
336 void setLogFile(const TQString& logfile);
337 void setReminder(int minutes, bool onceOnly);
338 bool defer(const DateTime&, bool reminder, bool adjustRecurrence = false);
339 void cancelDefer();
340 void cancelCancelledDeferral();
341 void setDeferDefaultMinutes(int minutes) { mDeferDefaultMinutes = minutes; mUpdated = true; }
342 bool setDisplaying(const KAEvent&, KAAlarm::Type, const TQDateTime&);
343 void reinstateFromDisplaying(const KAEvent& dispEvent);
344 void setArchive() { mArchive = true; mUpdated = true; }
345 void setEnabled(bool enable) { mEnabled = enable; mUpdated = true; }
346 void setUpdated() { mUpdated = true; }
347 void clearUpdated() const { mUpdated = false; }
348 void removeExpiredAlarm(KAAlarm::Type);
349 void incrementRevision() { ++mRevision; mUpdated = true; }
350
351 KCal::Event* event() const; // convert to new Event
352 bool isTemplate() const { return !mTemplateName.isEmpty(); }
353 const TQString& templateName() const { return mTemplateName; }
354 bool usingDefaultTime() const { return mTemplateAfterTime == 0; }
355 int templateAfterTime() const { return mTemplateAfterTime; }
356 KAAlarm alarm(KAAlarm::Type) const;
357 KAAlarm firstAlarm() const;
358 KAAlarm nextAlarm(const KAAlarm& al) const { return nextAlarm(al.type()); }
359 KAAlarm nextAlarm(KAAlarm::Type) const;
360 KAAlarm convertDisplayingAlarm() const;
361 bool updateKCalEvent(KCal::Event&, bool checkUid = true, bool original = false, bool cancelCancelledDefer = false) const;
362 Action action() const { return (Action)mActionType; }
363 bool displayAction() const { return mActionType == T_MESSAGE || mActionType == T_FILE; }
364 const TQString& id() const { return mEventID; }
365 bool valid() const { return mAlarmCount && (mAlarmCount != 1 || !mRepeatAtLogin); }
366 int alarmCount() const { return mAlarmCount; }
367 const DateTime& startDateTime() const { return mStartDateTime; }
368 DateTime mainDateTime(bool withRepeats = false) const
369 { return (withRepeats && mNextRepeat && mRepeatInterval)
370 ? mNextMainDateTime.addSecs(mNextRepeat * mRepeatInterval * 60) : mNextMainDateTime; }
371 TQDate mainDate() const { return mNextMainDateTime.date(); }
372 TQTime mainTime() const { return mNextMainDateTime.time(); }
373 DateTime mainEndRepeatTime() const { return (mRepeatCount > 0 && mRepeatInterval)
374 ? mNextMainDateTime.addSecs(mRepeatCount * mRepeatInterval * 60) : mNextMainDateTime; }
375 int reminder() const { return mReminderMinutes; }
376 bool reminderOnceOnly() const { return mReminderOnceOnly; }
377 bool reminderDeferral() const { return mDeferral == REMINDER_DEFERRAL; }
378 int reminderArchived() const { return mArchiveReminderMinutes; }
379 DateTime deferDateTime() const { return mDeferralTime; }
380 DateTime deferralLimit(DeferLimitType* = 0) const;
381 int deferDefaultMinutes() const { return mDeferDefaultMinutes; }
382 DateTime displayDateTime() const;
383 const TQString& messageFileOrCommand() const { return mText; }
384 TQString logFile() const { return mLogFile; }
385 bool commandXterm() const { return mCommandXterm; }
386 unsigned long kmailSerialNumber() const { return mKMailSerialNumber; }
387 bool copyToKOrganizer() const { return mCopyToKOrganizer; }
388 const TQString& audioFile() const { return mAudioFile; }
389 float soundVolume() const { return !mAudioFile.isEmpty() ? mSoundVolume : -1; }
390 float fadeVolume() const { return !mAudioFile.isEmpty() && mSoundVolume >= 0 && mFadeSeconds ? mFadeVolume : -1; }
391 int fadeSeconds() const { return !mAudioFile.isEmpty() && mSoundVolume >= 0 && mFadeVolume >= 0 ? mFadeSeconds : 0; }
392 bool repeatSound() const { return mRepeatSound && !mAudioFile.isEmpty(); }
393 const TQString& preAction() const { return mPreAction; }
394 const TQString& postAction() const { return mPostAction; }
395 bool recurs() const { return checkRecur() != KARecurrence::NO_RECUR; }
396 KARecurrence::Type recurType() const { return checkRecur(); }
397 KARecurrence* recurrence() const { return mRecurrence; }
398 int recurInterval() const; // recurrence period in units of the recurrence period type (minutes, days, etc)
399 int longestRecurrenceInterval() const { return mRecurrence ? mRecurrence->longestInterval() : 0; }
400 TQString recurrenceText(bool brief = false) const;
401 TQString repetitionText(bool brief = false) const;
402 bool occursAfter(const TQDateTime& preDateTime, bool includeRepetitions) const;
403 OccurType nextOccurrence(const TQDateTime& preDateTime, DateTime& result, OccurOption = IGNORE_REPETITION) const;
404 OccurType previousOccurrence(const TQDateTime& afterDateTime, DateTime& result, bool includeRepetitions = false) const;
405 int flags() const;
406 bool deferred() const { return mDeferral > 0; }
407 bool toBeArchived() const { return mArchive; }
408 bool enabled() const { return mEnabled; }
409 bool updated() const { return mUpdated; }
410 bool mainExpired() const { return mMainExpired; }
411 bool expired() const { return (mDisplaying && mMainExpired) || uidStatus(mEventID) == EXPIRED; }
412 Status uidStatus() const { return uidStatus(mEventID); }
413 static Status uidStatus(const TQString& uid);
414 static TQString uid(const TQString& id, Status);
415 static KAEvent findTemplateName(AlarmCalendar&, const TQString& name);
416
417 struct MonthPos
418 {
419 MonthPos() : days(7) { }
420 int weeknum; // week in month, or < 0 to count from end of month
421 TQBitArray days; // days in week
422 };
423 bool setRepetition(int interval, int count);
424 void setNoRecur() { clearRecur(); }
425 void setRecurrence(const KARecurrence&);
426 bool setRecurMinutely(int freq, int count, const TQDateTime& end);
427 bool setRecurDaily(int freq, const TQBitArray& days, int count, const TQDate& end);
428 bool setRecurWeekly(int freq, const TQBitArray& days, int count, const TQDate& end);
429 bool setRecurMonthlyByDate(int freq, const TQValueList<int>& days, int count, const TQDate& end);
430 bool setRecurMonthlyByPos(int freq, const TQValueList<MonthPos>& pos, int count, const TQDate& end);
431 bool setRecurAnnualByDate(int freq, const TQValueList<int>& months, int day, KARecurrence::Feb29Type, int count, const TQDate& end);
432 bool setRecurAnnualByPos(int freq, const TQValueList<MonthPos>& pos, const TQValueList<int>& months, int count, const TQDate& end);
433// static TQValueList<MonthPos> convRecurPos(const TQValueList<KCal::RecurrenceRule::WDayPos>&);
434#ifdef NDEBUG
435 void dumpDebug() const { }
436#else
437 void dumpDebug() const;
438#endif
439 static int calVersion();
440 static TQString calVersionString();
441 static bool adjustStartOfDay(const KCal::Event::List&);
442 static void convertKCalEvents(KCal::Calendar&, int version, bool adjustSummerTime);
443 static void convertRepetitions(KCal::CalendarLocal&);
444
445 private:
446 enum DeferType {
447 CANCEL_DEFERRAL = -1, // there was a deferred alarm, but it has been cancelled
448 NO_DEFERRAL = 0, // there is no deferred alarm
449 NORMAL_DEFERRAL, // the main alarm, a recurrence or a repeat is deferred
450 REMINDER_DEFERRAL // a reminder alarm is deferred
451 };
452
453 void copy(const KAEvent&);
454 bool setRecur(KCal::RecurrenceRule::PeriodType, int freq, int count, const TQDateTime& end, KARecurrence::Feb29Type = KARecurrence::FEB29_FEB29);
455 void clearRecur();
456 KARecurrence::Type checkRecur() const;
457 void checkRepetition() const;
458 OccurType nextRecurrence(const TQDateTime& preDateTime, DateTime& result) const;
459 OccurType previousRecurrence(const TQDateTime& afterDateTime, DateTime& result) const;
460 static bool convertRepetition(KCal::Event*);
461 KCal::Alarm* initKCalAlarm(KCal::Event&, const DateTime&, const TQStringList& types, KAAlarm::Type = KAAlarm::INVALID_ALARM) const;
462 KCal::Alarm* initKCalAlarm(KCal::Event&, int startOffsetSecs, const TQStringList& types, KAAlarm::Type = KAAlarm::INVALID_ALARM) const;
463 static DateTime readDateTime(const KCal::Event&, bool dateOnly, DateTime& start);
464 static void readAlarms(const KCal::Event&, void* alarmMap);
465 static void readAlarm(const KCal::Alarm&, AlarmData&);
466 inline void set_deferral(DeferType);
467 inline void set_reminder(int minutes);
468 inline void set_archiveReminder();
469
470 TQString mTemplateName; // alarm template's name, or null if normal event
471 TQString mAudioFile; // ATTACH: audio file to play
472 TQString mPreAction; // command to execute before alarm is displayed
473 TQString mPostAction; // command to execute after alarm window is closed
474 DateTime mStartDateTime; // DTSTART and DTEND: start and end time for event
475 TQDateTime mSaveDateTime; // CREATED: date event was created, or saved in expired calendar
476 TQDateTime mAtLoginDateTime; // repeat-at-login time
477 DateTime mDeferralTime; // extra time to trigger alarm (if alarm or reminder deferred)
478 DateTime mDisplayingTime; // date/time shown in the alarm currently being displayed
479 int mDisplayingFlags; // type of alarm which is currently being displayed
480 int mReminderMinutes; // how long in advance reminder is to be, or 0 if none
481 int mArchiveReminderMinutes; // original reminder period if now expired, or 0 if none
482 int mDeferDefaultMinutes; // default number of minutes for deferral dialogue, or 0 to select time control
483 int mRevision; // SEQUENCE: revision number of the original alarm, or 0
484 KARecurrence* mRecurrence; // RECUR: recurrence specification, or 0 if none
485 int mAlarmCount; // number of alarms: count of !mMainExpired, mRepeatAtLogin, mDeferral, mReminderMinutes, mDisplaying
486 DeferType mDeferral; // whether the alarm is an extra deferred/deferred-reminder alarm
487 unsigned long mKMailSerialNumber;// if email text, message's KMail serial number
488 int mTemplateAfterTime;// time not specified: use n minutes after default time, or -1 (applies to templates only)
489 TQString mLogFile; // alarm output is to be logged to this URL
490 bool mCommandXterm; // command alarm is to be executed in a terminal window
491 bool mCopyToKOrganizer; // KOrganizer should hold a copy of the event
492 bool mReminderOnceOnly; // the reminder is output only for the first recurrence
493 bool mMainExpired; // main alarm has expired (in which case a deferral alarm will exist)
494 bool mArchiveRepeatAtLogin; // if now expired, original event was repeat-at-login
495 bool mArchive; // event has triggered in the past, so archive it when closed
496 bool mEnabled; // false if event is disabled
497 mutable bool mUpdated; // event has been updated but not written to calendar file
498};
499
500#endif // KALARMEVENT_H
AlarmCalendar
Provides read and write access to calendar files.
Definition: alarmcalendar.h:37
KAEvent
KAEvent corresponds to a KCal::Event instance.
Definition: alarmevent.h:232
KAEvent::Status
Status
The category of an event, indicated by the middle part of its UID.
Definition: alarmevent.h:270