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.cpp10
1 files changed, 6 insertions, 4 deletions
diff --git a/libkcal/alarm.cpp b/libkcal/alarm.cpp
index 3157214..3c4a81c 100644
--- a/libkcal/alarm.cpp
+++ b/libkcal/alarm.cpp
@@ -1,483 +1,485 @@
/*
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 <klocale.h>
#include "incidence.h"
#include "todo.h"
#include "alarm.h"
+//Added by qt3to4:
+#include <Q3ValueList>
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 0
if ( mType != rhs.mType ) {
qDebug("aaa1 ");
return false;
}
if ( mAlarmSnoozeTime != rhs.mAlarmSnoozeTime ) {
qDebug("aaa2 ");
return false;
}
if ( mAlarmRepeatCount != rhs.mAlarmRepeatCount ) {
qDebug("aaa3 ");
return false;
}
if ( mAlarmEnabled != rhs.mAlarmEnabled ) {
qDebug("aaa4 ");
return false;
}
if ( mHasTime != rhs.mHasTime ) {
qDebug("aaa5 ");
return false;
}
#endif
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)
+ const Q3ValueList<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)
+void Alarm::setMailAddresses(const Q3ValueList<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
+Q3ValueList<Person> Alarm::mailAddresses() const
{
- return (mType == Email) ? mMailAddresses : QValueList<Person>();
+ return (mType == Email) ? mMailAddresses : Q3ValueList<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();
}
int Alarm::offset()
{
if ( hasTime() ) {
if (mParent->typeID() == todoID ) {
Todo *t = static_cast<Todo*>(mParent);
return t->dtDue().secsTo( mAlarmTime ) ;
} else
return mParent->dtStart().secsTo( mAlarmTime ) ;
}
else
{
return mOffset.asSeconds();
}
}
QString Alarm::offsetText()
{
int min = -offset()/60;
int hours = min /60;
min = min % 60;
int days = hours /24;
hours = hours % 24;
QString message;
//qDebug("%d %d %d ", days, hours, min );
if ( days > 0 )
message += i18n("%1d").arg( days );
if ( hours > 0 ) {
if ( !message.isEmpty() ) message += "/";
message += i18n("%1h").arg( hours );
}
if ( min > 0 ) {
if ( !message.isEmpty() ) message += "/";
message += i18n("%1min").arg( min );
}
if ( message.isEmpty() )
message = i18n("%1min").arg( 0 );
if ( !mParent->alarmEnabled() )
return "!"+message + i18n("(disabled)");
return message;
}
QDateTime Alarm::time() const
{
if ( hasTime() )
return mAlarmTime;
else
{
if (mParent->typeID() == todoID ) {
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;
}