00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
#include <kdebug.h>
00023
00024
#include "incidence.h"
00025
#include "todo.h"
00026
00027
#include "alarm.h"
00028
00029
using namespace KCal;
00030
00031 Alarm::Alarm(
Incidence *parent)
00032 : mParent(parent),
00033 mType(Invalid),
00034 mDescription(
""),
00035 mFile(
""),
00036 mMailSubject(
""),
00037 mAlarmSnoozeTime(5),
00038 mAlarmRepeatCount(0),
00039 mEndOffset(false),
00040 mHasTime(false),
00041 mAlarmEnabled(false)
00042 {
00043 }
00044
00045 Alarm::~Alarm()
00046 {
00047 }
00048
00049 bool Alarm::operator==(
const Alarm& rhs )
const
00050
{
00051
if ( mType != rhs.
mType ||
00052 mAlarmSnoozeTime != rhs.
mAlarmSnoozeTime ||
00053 mAlarmRepeatCount != rhs.
mAlarmRepeatCount ||
00054 mAlarmEnabled != rhs.
mAlarmEnabled ||
00055 mHasTime != rhs.
mHasTime)
00056
return false;
00057
00058
if (mHasTime) {
00059
if (mAlarmTime != rhs.
mAlarmTime)
00060
return false;
00061 }
else {
00062
if (mOffset != rhs.
mOffset ||
00063 mEndOffset != rhs.
mEndOffset)
00064
return false;
00065 }
00066
00067
switch (mType) {
00068
case Display:
00069
return mDescription == rhs.
mDescription;
00070
00071
case Email:
00072
return mDescription == rhs.
mDescription &&
00073 mMailAttachFiles == rhs.
mMailAttachFiles &&
00074 mMailAddresses == rhs.
mMailAddresses &&
00075 mMailSubject == rhs.
mMailSubject;
00076
00077
case Procedure:
00078
return mFile == rhs.
mFile &&
00079 mDescription == rhs.
mDescription;
00080
00081
case Audio:
00082
return mFile == rhs.
mFile;
00083
00084
case Invalid:
00085
break;
00086 }
00087
return false;
00088 }
00089
00090 void Alarm::setType(Alarm::Type type)
00091 {
00092
if (type == mType)
00093
return;
00094
00095
switch (type) {
00096
case Display:
00097 mDescription =
"";
00098
break;
00099
case Procedure:
00100 mFile = mDescription =
"";
00101
break;
00102
case Audio:
00103 mFile =
"";
00104
break;
00105
case Email:
00106 mMailSubject = mDescription =
"";
00107 mMailAddresses.clear();
00108 mMailAttachFiles.clear();
00109
break;
00110
case Invalid:
00111
break;
00112
default:
00113
return;
00114 }
00115 mType = type;
00116 mParent->
updated();
00117 }
00118
00119 Alarm::Type
Alarm::type()
const
00120
{
00121
return mType;
00122 }
00123
00124 void Alarm::setAudioAlarm(
const QString &audioFile)
00125 {
00126 mType = Audio;
00127 mFile = audioFile;
00128 mParent->
updated();
00129 }
00130
00131 void Alarm::setAudioFile(
const QString &audioFile)
00132 {
00133
if (mType == Audio) {
00134 mFile = audioFile;
00135 mParent->
updated();
00136 }
00137 }
00138
00139 QString Alarm::audioFile()
const
00140
{
00141
return (mType == Audio) ? mFile : QString::null;
00142 }
00143
00144 void Alarm::setProcedureAlarm(
const QString &programFile,
const QString &arguments)
00145 {
00146 mType = Procedure;
00147 mFile = programFile;
00148 mDescription = arguments;
00149 mParent->
updated();
00150 }
00151
00152 void Alarm::setProgramFile(
const QString &programFile)
00153 {
00154
if (mType == Procedure) {
00155 mFile = programFile;
00156 mParent->
updated();
00157 }
00158 }
00159
00160 QString Alarm::programFile()
const
00161
{
00162
return (mType == Procedure) ? mFile : QString::null;
00163 }
00164
00165 void Alarm::setProgramArguments(
const QString &arguments)
00166 {
00167
if (mType == Procedure) {
00168 mDescription = arguments;
00169 mParent->
updated();
00170 }
00171 }
00172
00173 QString Alarm::programArguments()
const
00174
{
00175
return (mType == Procedure) ? mDescription : QString::null;
00176 }
00177
00178 void Alarm::setEmailAlarm(
const QString &subject,
const QString &text,
00179
const QValueList<Person> &addressees,
const QStringList &attachments)
00180 {
00181 mType = Email;
00182 mMailSubject = subject;
00183 mDescription = text;
00184 mMailAddresses = addressees;
00185 mMailAttachFiles = attachments;
00186 mParent->
updated();
00187 }
00188
00189 void Alarm::setMailAddress(
const Person &mailAddress)
00190 {
00191
if (mType == Email) {
00192 mMailAddresses.clear();
00193 mMailAddresses += mailAddress;
00194 mParent->
updated();
00195 }
00196 }
00197
00198 void Alarm::setMailAddresses(
const QValueList<Person> &mailAddresses)
00199 {
00200
if (mType == Email) {
00201 mMailAddresses = mailAddresses;
00202 mParent->
updated();
00203 }
00204 }
00205
00206 void Alarm::addMailAddress(
const Person &mailAddress)
00207 {
00208
if (mType == Email) {
00209 mMailAddresses += mailAddress;
00210 mParent->
updated();
00211 }
00212 }
00213
00214 QValueList<Person> Alarm::mailAddresses()
const
00215
{
00216
return (mType == Email) ? mMailAddresses :
QValueList<Person>();
00217 }
00218
00219 void Alarm::setMailSubject(
const QString &mailAlarmSubject)
00220 {
00221
if (mType == Email) {
00222 mMailSubject = mailAlarmSubject;
00223 mParent->
updated();
00224 }
00225 }
00226
00227 QString Alarm::mailSubject()
const
00228
{
00229
return (mType == Email) ? mMailSubject : QString::null;
00230 }
00231
00232 void Alarm::setMailAttachment(
const QString &mailAttachFile)
00233 {
00234
if (mType == Email) {
00235 mMailAttachFiles.clear();
00236 mMailAttachFiles += mailAttachFile;
00237 mParent->
updated();
00238 }
00239 }
00240
00241 void Alarm::setMailAttachments(
const QStringList &mailAttachFiles)
00242 {
00243
if (mType == Email) {
00244 mMailAttachFiles = mailAttachFiles;
00245 mParent->
updated();
00246 }
00247 }
00248
00249 void Alarm::addMailAttachment(
const QString &mailAttachFile)
00250 {
00251
if (mType == Email) {
00252 mMailAttachFiles += mailAttachFile;
00253 mParent->
updated();
00254 }
00255 }
00256
00257 QStringList Alarm::mailAttachments()
const
00258
{
00259
return (mType == Email) ? mMailAttachFiles :
QStringList();
00260 }
00261
00262 void Alarm::setMailText(
const QString &text)
00263 {
00264
if (mType == Email) {
00265 mDescription = text;
00266 mParent->
updated();
00267 }
00268 }
00269
00270 QString Alarm::mailText()
const
00271
{
00272
return (mType == Email) ? mDescription : QString::null;
00273 }
00274
00275 void Alarm::setDisplayAlarm(
const QString &text)
00276 {
00277 mType = Display;
00278 mDescription = text;
00279 mParent->
updated();
00280 }
00281
00282 void Alarm::setText(
const QString &text)
00283 {
00284
if (mType == Display) {
00285 mDescription = text;
00286 mParent->
updated();
00287 }
00288 }
00289
00290 QString Alarm::text()
const
00291
{
00292
return (mType == Display) ? mDescription : QString::null;
00293 }
00294
00295 void Alarm::setTime(
const QDateTime &alarmTime)
00296 {
00297 mAlarmTime = alarmTime;
00298 mHasTime =
true;
00299
00300 mParent->
updated();
00301 }
00302
00303 QDateTime Alarm::time()
const
00304
{
00305
if (
hasTime() )
00306
return mAlarmTime;
00307
else
00308 {
00309
if (mParent->
type()==
"Todo") {
00310
Todo *t = static_cast<Todo*>(mParent);
00311
return mOffset.
end( t->
dtDue() );
00312 }
else if (mEndOffset) {
00313
return mOffset.
end( mParent->
dtEnd() );
00314 }
else {
00315
return mOffset.
end( mParent->
dtStart() );
00316 }
00317 }
00318 }
00319
00320 bool Alarm::hasTime()
const
00321
{
00322
return mHasTime;
00323 }
00324
00325 void Alarm::setSnoozeTime(
int alarmSnoozeTime)
00326 {
00327 mAlarmSnoozeTime = alarmSnoozeTime;
00328 mParent->
updated();
00329 }
00330
00331 int Alarm::snoozeTime()
const
00332
{
00333
return mAlarmSnoozeTime;
00334 }
00335
00336 void Alarm::setRepeatCount(
int alarmRepeatCount)
00337 {
00338 mAlarmRepeatCount = alarmRepeatCount;
00339 mParent->
updated();
00340 }
00341
00342 int Alarm::repeatCount()
const
00343
{
00344
return mAlarmRepeatCount;
00345 }
00346
00347 void Alarm::toggleAlarm()
00348 {
00349 mAlarmEnabled = !mAlarmEnabled;
00350 mParent->
updated();
00351 }
00352
00353 void Alarm::setEnabled(
bool enable)
00354 {
00355 mAlarmEnabled = enable;
00356 mParent->
updated();
00357 }
00358
00359 bool Alarm::enabled()
const
00360
{
00361
return mAlarmEnabled;
00362 }
00363
00364 void Alarm::setStartOffset(
const Duration &offset )
00365 {
00366 mOffset = offset;
00367 mEndOffset =
false;
00368 mHasTime =
false;
00369 mParent->
updated();
00370 }
00371
00372 Duration Alarm::startOffset()
const
00373
{
00374
return (mHasTime || mEndOffset) ? 0 : mOffset;
00375 }
00376
00377 bool Alarm::hasStartOffset()
const
00378
{
00379
return !mHasTime && !mEndOffset;
00380 }
00381
00382 bool Alarm::hasEndOffset()
const
00383
{
00384
return !mHasTime && mEndOffset;
00385 }
00386
00387 void Alarm::setEndOffset(
const Duration &offset )
00388 {
00389 mOffset = offset;
00390 mEndOffset =
true;
00391 mHasTime =
false;
00392 mParent->
updated();
00393 }
00394
00395 Duration Alarm::endOffset()
const
00396
{
00397
return (mHasTime || !mEndOffset) ? 0 : mOffset;
00398 }
00399
00400 void Alarm::setParent(
Incidence *parent )
00401 {
00402 mParent = parent;
00403 }