| -rw-r--r-- | libkcal/alarm.cpp | 407 |
1 files changed, 407 insertions, 0 deletions
diff --git a/libkcal/alarm.cpp b/libkcal/alarm.cpp new file mode 100644 index 0000000..07812c2 --- a/dev/null +++ b/libkcal/alarm.cpp @@ -0,0 +1,407 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include <kdebug.h> + +#include "incidence.h" +#include "todo.h" + +#include "alarm.h" + +using namespace KCal; +#include <qwidget.h> +Alarm::Alarm(Incidence *parent) + : mParent(parent), + mType(Audio), + 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; + mParent->updated(); +} + +Alarm::Type Alarm::type() const +{ + return mType; +} + +void Alarm::setAudioAlarm(const QString &audioFile) +{ + mType = Audio; + mFile = audioFile; + mParent->updated(); +} + +void Alarm::setAudioFile(const QString &audioFile) +{ + if (mType == Audio) { + mFile = audioFile; + 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; + mParent->updated(); +} + +void Alarm::setProgramFile(const QString &programFile) +{ + if (mType == Procedure) { + mFile = programFile; + mParent->updated(); + } +} + +QString Alarm::programFile() const +{ + return (mType == Procedure) ? mFile : QString::null; +} + +void Alarm::setProgramArguments(const QString &arguments) +{ + if (mType == Procedure) { + mDescription = arguments; + 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; + mParent->updated(); +} + +void Alarm::setMailAddress(const Person &mailAddress) +{ + if (mType == Email) { + mMailAddresses.clear(); + mMailAddresses += mailAddress; + mParent->updated(); + } +} + +void Alarm::setMailAddresses(const QValueList<Person> &mailAddresses) +{ + if (mType == Email) { + mMailAddresses = mailAddresses; + mParent->updated(); + } +} + +void Alarm::addMailAddress(const Person &mailAddress) +{ + if (mType == Email) { + mMailAddresses += mailAddress; + mParent->updated(); + } +} + +QValueList<Person> Alarm::mailAddresses() const +{ + return (mType == Email) ? mMailAddresses : QValueList<Person>(); +} + +void Alarm::setMailSubject(const QString &mailAlarmSubject) +{ + if (mType == Email) { + mMailSubject = mailAlarmSubject; + 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; + mParent->updated(); + } +} + +void Alarm::setMailAttachments(const QStringList &mailAttachFiles) +{ + if (mType == Email) { + mMailAttachFiles = mailAttachFiles; + mParent->updated(); + } +} + +void Alarm::addMailAttachment(const QString &mailAttachFile) +{ + if (mType == Email) { + mMailAttachFiles += mailAttachFile; + mParent->updated(); + } +} + +QStringList Alarm::mailAttachments() const +{ + return (mType == Email) ? mMailAttachFiles : QStringList(); +} + +void Alarm::setMailText(const QString &text) +{ + if (mType == Email) { + mDescription = text; + mParent->updated(); + } +} + +QString Alarm::mailText() const +{ + return (mType == Email) ? mDescription : QString::null; +} + +void Alarm::setDisplayAlarm(const QString &text) +{ + mType = Display; + mDescription = text; + mParent->updated(); +} + +void Alarm::setText(const QString &text) +{ + if (mType == Display) { + mDescription = text; + mParent->updated(); + } +} + +QString Alarm::text() const +{ + return (mType == Display) ? mDescription : QString::null; +} + +void Alarm::setTime(const QDateTime &alarmTime) +{ + mAlarmTime = alarmTime; + mHasTime = true; + + mParent->updated(); +} + +QDateTime Alarm::time() const +{ + if ( hasTime() ) + return mAlarmTime; + else + { + 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() ); + } + } +} + +bool Alarm::hasTime() const +{ + return mHasTime; +} + +void Alarm::setSnoozeTime(int alarmSnoozeTime) +{ + mAlarmSnoozeTime = alarmSnoozeTime; + mParent->updated(); +} + +int Alarm::snoozeTime() const +{ + return mAlarmSnoozeTime; +} + +void Alarm::setRepeatCount(int alarmRepeatCount) +{ + kdDebug(5800) << "Alarm::setRepeatCount(): " << alarmRepeatCount << endl; + + mAlarmRepeatCount = alarmRepeatCount; + mParent->updated(); +} + +int Alarm::repeatCount() const +{ + kdDebug(5800) << "Alarm::repeatCount(): " << mAlarmRepeatCount << endl; + return mAlarmRepeatCount; +} + +void Alarm::toggleAlarm() +{ + mAlarmEnabled = !mAlarmEnabled; + mParent->updated(); +} + +void Alarm::setEnabled(bool enable) +{ + mAlarmEnabled = enable; + mParent->updated(); +} + +bool Alarm::enabled() const +{ + return mAlarmEnabled; +} + +void Alarm::setStartOffset( const Duration &offset ) +{ + mOffset = offset; + mEndOffset = false; + mHasTime = false; + 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; + mParent->updated(); +} + +Duration Alarm::endOffset() const +{ + return (mHasTime || !mEndOffset) ? 0 : mOffset; +} + +void Alarm::setParent( Incidence *parent ) +{ + mParent = parent; +} |