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.
460 lines
10 KiB
460 lines
10 KiB
/*
|
|
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();
|
|
}
|