summaryrefslogtreecommitdiffabout
path: root/libkcal/alarm.cpp
Side-by-side diff
Diffstat (limited to 'libkcal/alarm.cpp') (more/less context) (show whitespace changes)
-rw-r--r--libkcal/alarm.cpp407
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;
+}