diff options
Diffstat (limited to 'libkcal/alarm.cpp')
| -rw-r--r-- | libkcal/alarm.cpp | 459 |
1 files changed, 459 insertions, 0 deletions
diff --git a/libkcal/alarm.cpp b/libkcal/alarm.cpp new file mode 100644 index 00000000..c4416fb7 --- /dev/null +++ b/libkcal/alarm.cpp @@ -0,0 +1,459 @@ +/* + This file is part of libkcal. + + Copyright (c) 1998 Preston Brown <pbrown@kde.org> + Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <kdebug.h> + +#include "incidence.h" +#include "todo.h" + +#include "alarm.h" + +using namespace KCal; + +Alarm::Alarm(Incidence *parent) + : mParent(parent), + mType(Invalid), + mDescription(""), // to make operator==() not fail + mFile(""), // to make operator==() not fail + mMailSubject(""), // to make operator==() not fail + mAlarmSnoozeTime(5), + mAlarmRepeatCount(0), + mEndOffset(false), + mHasTime(false), + mAlarmEnabled(false) +{ +} + +Alarm::~Alarm() +{ +} + +bool Alarm::operator==( const Alarm& rhs ) const +{ + if ( mType != rhs.mType || + mAlarmSnoozeTime != rhs.mAlarmSnoozeTime || + mAlarmRepeatCount != rhs.mAlarmRepeatCount || + mAlarmEnabled != rhs.mAlarmEnabled || + mHasTime != rhs.mHasTime) + return false; + + if (mHasTime) { + if (mAlarmTime != rhs.mAlarmTime) + return false; + } else { + if (mOffset != rhs.mOffset || + mEndOffset != rhs.mEndOffset) + return false; + } + + switch (mType) { + case Display: + return mDescription == rhs.mDescription; + + case Email: + return mDescription == rhs.mDescription && + mMailAttachFiles == rhs.mMailAttachFiles && + mMailAddresses == rhs.mMailAddresses && + mMailSubject == rhs.mMailSubject; + + case Procedure: + return mFile == rhs.mFile && + mDescription == rhs.mDescription; + + case Audio: + return mFile == rhs.mFile; + + case Invalid: + break; + } + return false; +} + +void Alarm::setType(Alarm::Type type) +{ + if (type == mType) + return; + + switch (type) { + case Display: + mDescription = ""; + break; + case Procedure: + mFile = mDescription = ""; + break; + case Audio: + mFile = ""; + break; + case Email: + mMailSubject = mDescription = ""; + mMailAddresses.clear(); + mMailAttachFiles.clear(); + break; + case Invalid: + break; + default: + return; + } + mType = type; + if ( mParent ) mParent->updated(); +} + +Alarm::Type Alarm::type() const +{ + return mType; +} + +void Alarm::setAudioAlarm(const QString &audioFile) +{ + mType = Audio; + mFile = audioFile; + if ( mParent ) mParent->updated(); +} + +void Alarm::setAudioFile(const QString &audioFile) +{ + if (mType == Audio) { + mFile = audioFile; + if ( mParent ) mParent->updated(); + } +} + +QString Alarm::audioFile() const +{ + return (mType == Audio) ? mFile : QString::null; +} + +void Alarm::setProcedureAlarm(const QString &programFile, const QString &arguments) +{ + mType = Procedure; + mFile = programFile; + mDescription = arguments; + if ( mParent ) mParent->updated(); +} + +void Alarm::setProgramFile(const QString &programFile) +{ + if (mType == Procedure) { + mFile = programFile; + if ( mParent ) mParent->updated(); + } +} + +QString Alarm::programFile() const +{ + return (mType == Procedure) ? mFile : QString::null; +} + +void Alarm::setProgramArguments(const QString &arguments) +{ + if (mType == Procedure) { + mDescription = arguments; + if ( mParent ) mParent->updated(); + } +} + +QString Alarm::programArguments() const +{ + return (mType == Procedure) ? mDescription : QString::null; +} + +void Alarm::setEmailAlarm(const QString &subject, const QString &text, + const QValueList<Person> &addressees, const QStringList &attachments) +{ + mType = Email; + mMailSubject = subject; + mDescription = text; + mMailAddresses = addressees; + mMailAttachFiles = attachments; + if ( mParent ) mParent->updated(); +} + +void Alarm::setMailAddress(const Person &mailAddress) +{ + if (mType == Email) { + mMailAddresses.clear(); + mMailAddresses += mailAddress; + if ( mParent ) mParent->updated(); + } +} + +void Alarm::setMailAddresses(const QValueList<Person> &mailAddresses) +{ + if (mType == Email) { + mMailAddresses = mailAddresses; + if ( mParent ) mParent->updated(); + } +} + +void Alarm::addMailAddress(const Person &mailAddress) +{ + if (mType == Email) { + mMailAddresses += mailAddress; + if ( mParent ) mParent->updated(); + } +} + +QValueList<Person> Alarm::mailAddresses() const +{ + return (mType == Email) ? mMailAddresses : QValueList<Person>(); +} + +void Alarm::setMailSubject(const QString &mailAlarmSubject) +{ + if (mType == Email) { + mMailSubject = mailAlarmSubject; + if ( mParent ) mParent->updated(); + } +} + +QString Alarm::mailSubject() const +{ + return (mType == Email) ? mMailSubject : QString::null; +} + +void Alarm::setMailAttachment(const QString &mailAttachFile) +{ + if (mType == Email) { + mMailAttachFiles.clear(); + mMailAttachFiles += mailAttachFile; + if ( mParent ) mParent->updated(); + } +} + +void Alarm::setMailAttachments(const QStringList &mailAttachFiles) +{ + if (mType == Email) { + mMailAttachFiles = mailAttachFiles; + if ( mParent ) mParent->updated(); + } +} + +void Alarm::addMailAttachment(const QString &mailAttachFile) +{ + if (mType == Email) { + mMailAttachFiles += mailAttachFile; + if ( mParent ) mParent->updated(); + } +} + +QStringList Alarm::mailAttachments() const +{ + return (mType == Email) ? mMailAttachFiles : QStringList(); +} + +void Alarm::setMailText(const QString &text) +{ + if (mType == Email) { + mDescription = text; + if ( mParent ) mParent->updated(); + } +} + +QString Alarm::mailText() const +{ + return (mType == Email) ? mDescription : QString::null; +} + +void Alarm::setDisplayAlarm(const QString &text) +{ + mType = Display; + if ( !text.isNull() ) + mDescription = text; + if ( mParent ) mParent->updated(); +} + +void Alarm::setText(const QString &text) +{ + if (mType == Display) { + mDescription = text; + if ( mParent ) mParent->updated(); + } +} + +QString Alarm::text() const +{ + return (mType == Display) ? mDescription : QString::null; +} + +void Alarm::setTime(const QDateTime &alarmTime) +{ + mAlarmTime = alarmTime; + mHasTime = true; + + if ( mParent ) mParent->updated(); +} + +QDateTime Alarm::time() const +{ + if ( hasTime() ) + return mAlarmTime; + else if ( mParent ) + { + if (mParent->type()=="Todo") { + Todo *t = static_cast<Todo*>(mParent); + return mOffset.end( t->dtDue() ); + } else if (mEndOffset) { + return mOffset.end( mParent->dtEnd() ); + } else { + return mOffset.end( mParent->dtStart() ); + } + } else return QDateTime(); +} + +bool Alarm::hasTime() const +{ + return mHasTime; +} + +void Alarm::setSnoozeTime(int alarmSnoozeTime) +{ + if (alarmSnoozeTime > 0) { + mAlarmSnoozeTime = alarmSnoozeTime; + if ( mParent ) mParent->updated(); + } +} + +int Alarm::snoozeTime() const +{ + return mAlarmSnoozeTime; +} + +void Alarm::setRepeatCount(int alarmRepeatCount) +{ + mAlarmRepeatCount = alarmRepeatCount; + if ( mParent ) mParent->updated(); +} + +int Alarm::repeatCount() const +{ + return mAlarmRepeatCount; +} + +int Alarm::duration() const +{ + return mAlarmRepeatCount * mAlarmSnoozeTime * 60; +} + +QDateTime Alarm::nextRepetition(const QDateTime& preTime) const +{ + // This method is coded to avoid 32-bit integer overflow using + // QDateTime::secsTo(), which occurs with time spans > 68 years. + QDateTime at = time(); + if (at > preTime) + return at; + if (!mAlarmRepeatCount) + return QDateTime(); // there isn't an occurrence after the specified time + int snoozeSecs = mAlarmSnoozeTime * 60; + QDateTime lastRepetition = at.addSecs(mAlarmRepeatCount * snoozeSecs); + if (lastRepetition <= preTime) + return QDateTime(); // all repetitions have finished before the specified time + int repetition = (at.secsTo(preTime) + snoozeSecs) / snoozeSecs; + return at.addSecs(repetition * snoozeSecs); +} + +QDateTime Alarm::previousRepetition(const QDateTime& afterTime) const +{ + // This method is coded to avoid 32-bit integer overflow using + // QDateTime::secsTo(), which occurs with time spans > 68 years. + QDateTime at = time(); + if (at >= afterTime) + return QDateTime(); // alarm's first/only time is at/after the specified time + if (!mAlarmRepeatCount) + return at; + int snoozeSecs = mAlarmSnoozeTime * 60; + QDateTime lastRepetition = at.addSecs(mAlarmRepeatCount * snoozeSecs); + if (lastRepetition < afterTime) + return lastRepetition; // all repetitions have finished before the specified time + int repetition = (at.secsTo(afterTime) - 1) / snoozeSecs; + return at.addSecs(repetition * snoozeSecs); +} + +QDateTime Alarm::endTime() const +{ + if (mAlarmRepeatCount) + return time().addSecs(mAlarmRepeatCount * mAlarmSnoozeTime * 60); + else + return time(); +} + +void Alarm::toggleAlarm() +{ + mAlarmEnabled = !mAlarmEnabled; + if ( mParent ) mParent->updated(); +} + +void Alarm::setEnabled(bool enable) +{ + mAlarmEnabled = enable; + if ( mParent ) mParent->updated(); +} + +bool Alarm::enabled() const +{ + return mAlarmEnabled; +} + +void Alarm::setStartOffset( const Duration &offset ) +{ + mOffset = offset; + mEndOffset = false; + mHasTime = false; + if ( mParent ) mParent->updated(); +} + +Duration Alarm::startOffset() const +{ + return (mHasTime || mEndOffset) ? 0 : mOffset; +} + +bool Alarm::hasStartOffset() const +{ + return !mHasTime && !mEndOffset; +} + +bool Alarm::hasEndOffset() const +{ + return !mHasTime && mEndOffset; +} + +void Alarm::setEndOffset( const Duration &offset ) +{ + mOffset = offset; + mEndOffset = true; + mHasTime = false; + if ( mParent ) mParent->updated(); +} + +Duration Alarm::endOffset() const +{ + return (mHasTime || !mEndOffset) ? 0 : mOffset; +} + +void Alarm::setParent( Incidence *parent ) +{ + mParent = parent; +} + +void Alarm::customPropertyUpdated() +{ + if ( mParent ) mParent->updated(); +} |