You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
501 lines
31 KiB
501 lines
31 KiB
/*
|
|
* 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 <tqcolor.h>
|
|
#include <tqfont.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 TQValueList<KCal::Person>
|
|
{
|
|
public:
|
|
EmailAddressList() : TQValueList<KCal::Person>() { }
|
|
EmailAddressList(const TQValueList<KCal::Person>& list) { operator=(list); }
|
|
EmailAddressList& operator=(const TQValueList<KCal::Person>&);
|
|
TQString join(const TQString& separator) const;
|
|
};
|
|
|
|
|
|
// Base class containing data common to KAAlarm and KAEvent
|
|
class KAAlarmEventBase
|
|
{
|
|
public:
|
|
~KAAlarmEventBase() { }
|
|
const TQString& cleanText() const { return mText; }
|
|
TQString message() const { return (mActionType == T_MESSAGE || mActionType == T_EMAIL) ? mText : TQString(); }
|
|
TQString fileName() const { return (mActionType == T_FILE) ? mText : TQString(); }
|
|
TQString command() const { return (mActionType == T_COMMAND) ? mText : TQString(); }
|
|
uint emailFromId() const { return mEmailFromIdentity; }
|
|
const EmailAddressList& emailAddresses() const { return mEmailAddresses; }
|
|
TQString emailAddresses(const TQString& sep) const { return mEmailAddresses.join(sep); }
|
|
const TQString& emailSubject() const { return mEmailSubject; }
|
|
const TQStringList& emailAttachments() const { return mEmailAttachments; }
|
|
TQString emailAttachments(const TQString& sep) const { return mEmailAttachments.join(sep); }
|
|
bool emailBcc() const { return mEmailBcc; }
|
|
const TQColor& bgColour() const { return mBgColour; }
|
|
const TQColor& fgColour() const { return mFgColour; }
|
|
bool defaultFont() const { return mDefaultFont; }
|
|
const TQFont& 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);
|
|
|
|
TQString mEventID; // UID: KCal::Event unique ID
|
|
TQString mText; // message text, file URL, command, email body [or audio file for KAAlarm]
|
|
DateTime mNextMainDateTime; // next time to display the alarm, excluding repetitions
|
|
TQColor mBgColour; // background colour of alarm message
|
|
TQColor mFgColour; // foreground colour of alarm message, or invalid for default
|
|
TQFont 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
|
|
TQString mEmailSubject; // SUMMARY: subject line of email
|
|
TQStringList 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 bimask 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 bimask 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 TQString& eventID() const { return mEventID; }
|
|
DateTime dateTime(bool withRepeats = false) const
|
|
{ return (withRepeats && mNextRepeat && mRepeatInterval)
|
|
? mNextMainDateTime.addSecs(mNextRepeat * mRepeatInterval * 60) : mNextMainDateTime; }
|
|
TQDate date() const { return mNextMainDateTime.date(); }
|
|
TQTime time() const { return mNextMainDateTime.time(); }
|
|
TQString audioFile() const { return (mActionType == T_AUDIO) && !mBeep ? mText : TQString(); }
|
|
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 TQDateTime& 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, // (bimask 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 TQDateTime& dt, const TQString& message, const TQColor& bg, const TQColor& fg, const TQFont& 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 TQDateTime&, const TQString& message, const TQColor& bg, const TQColor& fg, const TQFont&, Action, int lateCancel, int flags);
|
|
void setEmail(uint from, const EmailAddressList&, const TQString& subject, const TQStringList& attachments);
|
|
void setAudioFile(const TQString& filename, float volume, float fadeVolume, int fadeSeconds);
|
|
void setTemplate(const TQString& name, int afterTime = -1) { mTemplateName = name; mTemplateAfterTime = afterTime; mUpdated = true; }
|
|
void setActions(const TQString& pre, const TQString& post) { mPreAction = pre; mPostAction = post; mUpdated = true; }
|
|
OccurType setNextOccurrence(const TQDateTime& preDateTime);
|
|
void setFirstRecurrence();
|
|
void setEventID(const TQString& id) { mEventID = id; mUpdated = true; }
|
|
void setDate(const TQDate& d) { mNextMainDateTime.set(d); mUpdated = true; }
|
|
void setTime(const TQDateTime& dt) { mNextMainDateTime.set(dt); mUpdated = true; }
|
|
void setSaveDateTime(const TQDateTime& 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 TQString& 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 TQDateTime&);
|
|
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 TQString& 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 TQString& 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; }
|
|
TQDate mainDate() const { return mNextMainDateTime.date(); }
|
|
TQTime 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 TQString& messageFileOrCommand() const { return mText; }
|
|
TQString logFile() const { return mLogFile; }
|
|
bool commandXterm() const { return mCommandXterm; }
|
|
unsigned long kmailSerialNumber() const { return mKMailSerialNumber; }
|
|
bool copyToKOrganizer() const { return mCopyToKOrganizer; }
|
|
const TQString& 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 TQString& preAction() const { return mPreAction; }
|
|
const TQString& 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; }
|
|
TQString recurrenceText(bool brief = false) const;
|
|
TQString repetitionText(bool brief = false) const;
|
|
bool occursAfter(const TQDateTime& preDateTime, bool includeRepetitions) const;
|
|
OccurType nextOccurrence(const TQDateTime& preDateTime, DateTime& result, OccurOption = IGNORE_REPETITION) const;
|
|
OccurType previousOccurrence(const TQDateTime& 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 TQString& uid);
|
|
static TQString uid(const TQString& id, Status);
|
|
static KAEvent findTemplateName(AlarmCalendar&, const TQString& name);
|
|
|
|
struct MonthPos
|
|
{
|
|
MonthPos() : days(7) { }
|
|
int weeknum; // week in month, or < 0 to count from end of month
|
|
TQBitArray days; // days in week
|
|
};
|
|
bool setRepetition(int interval, int count);
|
|
void setNoRecur() { clearRecur(); }
|
|
void setRecurrence(const KARecurrence&);
|
|
bool setRecurMinutely(int freq, int count, const TQDateTime& end);
|
|
bool setRecurDaily(int freq, const TQBitArray& days, int count, const TQDate& end);
|
|
bool setRecurWeekly(int freq, const TQBitArray& days, int count, const TQDate& end);
|
|
bool setRecurMonthlyByDate(int freq, const TQValueList<int>& days, int count, const TQDate& end);
|
|
bool setRecurMonthlyByPos(int freq, const TQValueList<MonthPos>& pos, int count, const TQDate& end);
|
|
bool setRecurAnnualByDate(int freq, const TQValueList<int>& months, int day, KARecurrence::Feb29Type, int count, const TQDate& end);
|
|
bool setRecurAnnualByPos(int freq, const TQValueList<MonthPos>& pos, const TQValueList<int>& months, int count, const TQDate& end);
|
|
// static TQValueList<MonthPos> convRecurPos(const TQValueList<KCal::RecurrenceRule::WDayPos>&);
|
|
#ifdef NDEBUG
|
|
void dumpDebug() const { }
|
|
#else
|
|
void dumpDebug() const;
|
|
#endif
|
|
static int calVersion();
|
|
static TQString 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 TQDateTime& end, KARecurrence::Feb29Type = KARecurrence::FEB29_FEB29);
|
|
void clearRecur();
|
|
KARecurrence::Type checkRecur() const;
|
|
void checkRepetition() const;
|
|
OccurType nextRecurrence(const TQDateTime& preDateTime, DateTime& result) const;
|
|
OccurType previousRecurrence(const TQDateTime& afterDateTime, DateTime& result) const;
|
|
static bool convertRepetition(KCal::Event*);
|
|
KCal::Alarm* initKCalAlarm(KCal::Event&, const DateTime&, const TQStringList& types, KAAlarm::Type = KAAlarm::INVALID_ALARM) const;
|
|
KCal::Alarm* initKCalAlarm(KCal::Event&, int startOffsetSecs, const TQStringList& 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();
|
|
|
|
TQString mTemplateName; // alarm template's name, or null if normal event
|
|
TQString mAudioFile; // ATTACH: audio file to play
|
|
TQString mPreAction; // command to execute before alarm is displayed
|
|
TQString mPostAction; // command to execute after alarm window is closed
|
|
DateTime mStartDateTime; // DTSTART and DTEND: start and end time for event
|
|
TQDateTime mSaveDateTime; // CREATED: date event was created, or saved in expired calendar
|
|
TQDateTime 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)
|
|
TQString 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
|