00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "kalarm.h"
00022
00023 #include <qobject.h>
00024 #include <qstringlist.h>
00025
00026 #include <kapplication.h>
00027 #include <klocale.h>
00028 #include <kmessagebox.h>
00029 #include <kdebug.h>
00030
00031 #include "alarmcalendar.h"
00032 #include "alarmevent.h"
00033 #include "alarmtext.h"
00034 #include "functions.h"
00035 #include "undo.moc"
00036
00037 static int maxCount = 12;
00038
00039
00040 class UndoItem
00041 {
00042 public:
00043 enum Operation { ADD, EDIT, DELETE, REACTIVATE, DEACTIVATE, MULTI };
00044 UndoItem();
00045 virtual ~UndoItem();
00046 virtual Operation operation() const = 0;
00047 virtual QString actionText() const = 0;
00048 virtual QString description() const { return QString::null; }
00049 virtual QString eventID() const { return QString::null; }
00050 virtual QString oldEventID() const { return QString::null; }
00051 virtual QString newEventID() const { return QString::null; }
00052 int id() const { return mId; }
00053 Undo::Type type() const { return mType; }
00054 void setType(Undo::Type t) { mType = t; }
00055 KAEvent::Status calendar() const { return mCalendar; }
00056 virtual void setCalendar(KAEvent::Status s) { mCalendar = s; }
00057 virtual UndoItem* restore() = 0;
00058 virtual bool deleteID(const QString& ) { return false; }
00059
00060 enum Error { ERR_NONE, ERR_PROG, ERR_NOT_FOUND, ERR_CREATE, ERR_EXPIRED };
00061 enum Warning { WARN_NONE, WARN_KORG_ADD, WARN_KORG_MODIFY, WARN_KORG_DELETE };
00062 static int mLastId;
00063 static Error mRestoreError;
00064 static Warning mRestoreWarning;
00065 static int mRestoreWarningCount;
00066
00067 protected:
00068 UndoItem(Undo::Type);
00069 static QString addDeleteActionText(KAEvent::Status, bool add);
00070 QString description(const KAEvent&) const;
00071 void replaceWith(UndoItem* item) { Undo::replace(this, item); }
00072
00073 int mId;
00074 Undo::Type mType;
00075 KAEvent::Status mCalendar;
00076 };
00077
00078 class UndoMultiBase : public UndoItem
00079 {
00080 public:
00081 UndoMultiBase(Undo::Type t) : UndoItem(t) { }
00082 UndoMultiBase(Undo::Type t, Undo::List& undos) : UndoItem(t), mUndos(undos) { }
00083 ~UndoMultiBase();
00084 const Undo::List& undos() const { return mUndos; }
00085 protected:
00086 Undo::List mUndos;
00087 };
00088
00089 template <class T> class UndoMulti : public UndoMultiBase
00090 {
00091 public:
00092 UndoMulti(Undo::Type, const QValueList<KAEvent>&);
00093 UndoMulti(Undo::Type t, Undo::List& undos) : UndoMultiBase(t, undos) { }
00094 virtual Operation operation() const { return MULTI; }
00095 virtual UndoItem* restore();
00096 virtual bool deleteID(const QString& id);
00097 virtual UndoItem* createRedo(Undo::List&) = 0;
00098 };
00099
00100 class UndoAdd : public UndoItem
00101 {
00102 public:
00103 UndoAdd(Undo::Type, const KAEvent&);
00104 UndoAdd(Undo::Type, const KAEvent&, KAEvent::Status);
00105 virtual Operation operation() const { return ADD; }
00106 virtual QString actionText() const;
00107 virtual QString description() const { return mDescription; }
00108 virtual QString eventID() const { return mEventID; }
00109 virtual QString newEventID() const { return mEventID; }
00110 virtual UndoItem* restore() { return doRestore(); }
00111 protected:
00112 UndoItem* doRestore(bool setArchive = false);
00113 virtual UndoItem* createRedo(const KAEvent&);
00114 private:
00115 QString mEventID;
00116 QString mDescription;
00117 };
00118
00119 class UndoEdit : public UndoItem
00120 {
00121 public:
00122 UndoEdit(Undo::Type, const KAEvent& oldEvent, const QString& newEventID, const QString& description);
00123 ~UndoEdit();
00124 virtual Operation operation() const { return EDIT; }
00125 virtual QString actionText() const;
00126 virtual QString description() const { return mDescription; }
00127 virtual QString eventID() const { return mNewEventID; }
00128 virtual QString oldEventID() const { return mOldEvent->id(); }
00129 virtual QString newEventID() const { return mNewEventID; }
00130 virtual UndoItem* restore();
00131 private:
00132 KAEvent* mOldEvent;
00133 QString mNewEventID;
00134 QString mDescription;
00135 };
00136
00137 class UndoDelete : public UndoItem
00138 {
00139 public:
00140 UndoDelete(Undo::Type, const KAEvent&);
00141 ~UndoDelete();
00142 virtual Operation operation() const { return DELETE; }
00143 virtual QString actionText() const;
00144 virtual QString description() const { return UndoItem::description(*mEvent); }
00145 virtual QString eventID() const { return mEvent->id(); }
00146 virtual QString oldEventID() const { return mEvent->id(); }
00147 virtual UndoItem* restore();
00148 KAEvent* event() const { return mEvent; }
00149 protected:
00150 virtual UndoItem* createRedo(const KAEvent&);
00151 private:
00152 KAEvent* mEvent;
00153 };
00154
00155 class UndoReactivate : public UndoAdd
00156 {
00157 public:
00158 UndoReactivate(Undo::Type t, const KAEvent& e) : UndoAdd(t, e, KAEvent::ACTIVE) { }
00159 virtual Operation operation() const { return REACTIVATE; }
00160 virtual QString actionText() const;
00161 virtual UndoItem* restore();
00162 protected:
00163 virtual UndoItem* createRedo(const KAEvent&);
00164 };
00165
00166 class UndoDeactivate : public UndoDelete
00167 {
00168 public:
00169 UndoDeactivate(Undo::Type t, const KAEvent& e) : UndoDelete(t, e) { }
00170 virtual Operation operation() const { return DEACTIVATE; }
00171 virtual QString actionText() const;
00172 virtual UndoItem* restore();
00173 protected:
00174 virtual UndoItem* createRedo(const KAEvent&);
00175 };
00176
00177 class UndoDeletes : public UndoMulti<UndoDelete>
00178 {
00179 public:
00180 UndoDeletes(Undo::Type t, const QValueList<KAEvent>& events)
00181 : UndoMulti<UndoDelete>(t, events) { }
00182 UndoDeletes(Undo::Type t, Undo::List& undos)
00183 : UndoMulti<UndoDelete>(t, undos) { }
00184 virtual QString actionText() const;
00185 virtual UndoItem* createRedo(Undo::List&);
00186 };
00187
00188 class UndoReactivates : public UndoMulti<UndoReactivate>
00189 {
00190 public:
00191 UndoReactivates(Undo::Type t, const QValueList<KAEvent>& events)
00192 : UndoMulti<UndoReactivate>(t, events) { }
00193 UndoReactivates(Undo::Type t, Undo::List& undos)
00194 : UndoMulti<UndoReactivate>(t, undos) { }
00195 virtual QString actionText() const;
00196 virtual UndoItem* createRedo(Undo::List&);
00197 };
00198
00199 Undo* Undo::mInstance = 0;
00200 Undo::List Undo::mUndoList;
00201 Undo::List Undo::mRedoList;
00202
00203
00204
00205
00206
00207 Undo* Undo::instance()
00208 {
00209 if (!mInstance)
00210 mInstance = new Undo(kapp);
00211 return mInstance;
00212 }
00213
00214
00215
00216
00217 void Undo::clear()
00218 {
00219 if (!mUndoList.isEmpty() || !mRedoList.isEmpty())
00220 {
00221 mInstance->blockSignals(true);
00222 while (mUndoList.count())
00223 delete mUndoList.first();
00224 while (mRedoList.count())
00225 delete mRedoList.first();
00226 mInstance->blockSignals(false);
00227 emitChanged();
00228 }
00229 }
00230
00231
00232
00233
00234
00235 void Undo::saveAdd(const KAEvent& event)
00236 {
00237 new UndoAdd(UNDO, event);
00238 emitChanged();
00239 }
00240
00241 void Undo::saveEdit(const KAEvent& oldEvent, const KAEvent& newEvent)
00242 {
00243 new UndoEdit(UNDO, oldEvent, newEvent.id(), AlarmText::summary(newEvent));
00244 removeRedos(oldEvent.id());
00245 emitChanged();
00246 }
00247
00248 void Undo::saveDelete(const KAEvent& event)
00249 {
00250 new UndoDelete(UNDO, event);
00251 removeRedos(event.id());
00252 emitChanged();
00253 }
00254
00255 void Undo::saveDeletes(const QValueList<KAEvent>& events)
00256 {
00257 int count = events.count();
00258 if (count == 1)
00259 saveDelete(events.first());
00260 else if (count > 1)
00261 {
00262 new UndoDeletes(UNDO, events);
00263 for (QValueList<KAEvent>::ConstIterator it = events.begin(); it != events.end(); ++it)
00264 removeRedos((*it).id());
00265 emitChanged();
00266 }
00267 }
00268
00269 void Undo::saveReactivate(const KAEvent& event)
00270 {
00271 new UndoReactivate(UNDO, event);
00272 emitChanged();
00273 }
00274
00275 void Undo::saveReactivates(const QValueList<KAEvent>& events)
00276 {
00277 int count = events.count();
00278 if (count == 1)
00279 saveReactivate(events.first());
00280 else if (count > 1)
00281 {
00282 new UndoReactivates(UNDO, events);
00283 emitChanged();
00284 }
00285 }
00286
00287
00288
00289
00290 void Undo::removeRedos(const QString& eventID)
00291 {
00292 QString id = eventID;
00293 for (Iterator it = mRedoList.begin(); it != mRedoList.end(); )
00294 {
00295 UndoItem* item = *it;
00296
00297 if (item->operation() == UndoItem::MULTI)
00298 {
00299 if (item->deleteID(id))
00300 {
00301
00302 delete item;
00303 }
00304 ++it;
00305 }
00306 else if (item->eventID() == id)
00307 {
00308 if (item->operation() == UndoItem::EDIT)
00309 id = item->oldEventID();
00310 item->setType(NONE);
00311 delete item;
00312 it = mRedoList.remove(it);
00313 }
00314 else
00315 ++it;
00316 }
00317 }
00318
00319
00320
00321
00322
00323 bool Undo::undo(Undo::Iterator it, Undo::Type type, QWidget* parent, const QString& action)
00324 {
00325 UndoItem::mRestoreError = UndoItem::ERR_NONE;
00326 UndoItem::mRestoreWarning = UndoItem::WARN_NONE;
00327 UndoItem::mRestoreWarningCount = 0;
00328 if (it != mUndoList.end() && it != mRedoList.end() && (*it)->type() == type)
00329 {
00330 (*it)->restore();
00331 delete *it;
00332 emitChanged();
00333 }
00334
00335 QString err;
00336 switch (UndoItem::mRestoreError)
00337 {
00338 case UndoItem::ERR_NONE:
00339 {
00340 KAlarm::UpdateError errcode;
00341 switch (UndoItem::mRestoreWarning)
00342 {
00343 case UndoItem::WARN_KORG_ADD: errcode = KAlarm::KORG_ERR_ADD; break;
00344 case UndoItem::WARN_KORG_MODIFY: errcode = KAlarm::KORG_ERR_MODIFY; break;
00345 case UndoItem::WARN_KORG_DELETE: errcode = KAlarm::KORG_ERR_DELETE; break;
00346 case UndoItem::WARN_NONE:
00347 default:
00348 return true;
00349 }
00350 KAlarm::displayKOrgUpdateError(parent, errcode, UndoItem::mRestoreWarningCount);
00351 return true;
00352 }
00353 case UndoItem::ERR_NOT_FOUND: err = i18n("Alarm not found"); break;
00354 case UndoItem::ERR_CREATE: err = i18n("Error recreating alarm"); break;
00355 case UndoItem::ERR_EXPIRED: err = i18n("Cannot reactivate expired alarm"); break;
00356 case UndoItem::ERR_PROG: err = i18n("Program error"); break;
00357 default: err = i18n("Unknown error"); break;
00358 }
00359 KMessageBox::sorry(parent, i18n("Undo-action: message", "%1: %2").arg(action).arg(err));
00360 return false;
00361 }
00362
00363
00364
00365
00366 void Undo::add(UndoItem* item, bool undo)
00367 {
00368 if (item)
00369 {
00370
00371 int undoCount = mUndoList.count();
00372 int redoCount = mRedoList.count();
00373 if (undoCount + redoCount >= maxCount - 1)
00374 {
00375 if (undoCount)
00376 mUndoList.pop_back();
00377 else
00378 mRedoList.pop_back();
00379 }
00380
00381
00382 List* list = undo ? &mUndoList : &mRedoList;
00383 list->prepend(item);
00384 }
00385 }
00386
00387
00388
00389
00390 void Undo::remove(UndoItem* item, bool undo)
00391 {
00392 List* list = undo ? &mUndoList : &mRedoList;
00393 if (!list->isEmpty())
00394 list->remove(item);
00395 }
00396
00397
00398
00399
00400 void Undo::replace(UndoItem* old, UndoItem* New)
00401 {
00402 Type type = old->type();
00403 List* list = (type == UNDO) ? &mUndoList : (type == REDO) ? &mRedoList : 0;
00404 if (!list)
00405 return;
00406 Iterator it = list->find(old);
00407 if (it != list->end())
00408 {
00409 New->setType(type);
00410 *it = New;
00411 old->setType(NONE);
00412 }
00413 }
00414
00415
00416
00417
00418 QString Undo::actionText(Undo::Type type)
00419 {
00420 List* list = (type == UNDO) ? &mUndoList : (type == REDO) ? &mRedoList : 0;
00421 return (list && !list->isEmpty()) ? list->first()->actionText() : QString::null;
00422 }
00423
00424
00425
00426
00427 QString Undo::actionText(Undo::Type type, int id)
00428 {
00429 UndoItem* undo = getItem(id, type);
00430 return undo ? undo->actionText() : QString::null;
00431 }
00432
00433
00434
00435
00436 QString Undo::description(Undo::Type type, int id)
00437 {
00438 UndoItem* undo = getItem(id, type);
00439 return undo ? undo->description() : QString::null;
00440 }
00441
00442
00443
00444
00445
00446
00447
00448 QValueList<int> Undo::ids(Undo::Type type)
00449 {
00450 QValueList<int> ids;
00451 QStringList ignoreIDs;
00452
00453 List* list = (type == UNDO) ? &mUndoList : (type == REDO) ? &mRedoList : 0;
00454 if (!list)
00455 return ids;
00456 for (Iterator it = list->begin(); it != list->end(); ++it)
00457 {
00458
00459
00460 UndoItem* item = *it;
00461 bool omit = false;
00462 if (item->operation() == UndoItem::MULTI)
00463 {
00464
00465 QStringList newIDs;
00466 const Undo::List& undos = ((UndoMultiBase*)item)->undos();
00467 for (Undo::List::ConstIterator u = undos.begin(); u != undos.end(); ++u)
00468 {
00469 QString evid = (*u)->eventID();
00470 if (ignoreIDs.find(evid) != ignoreIDs.end())
00471 omit = true;
00472 else if (omit)
00473 ignoreIDs.append(evid);
00474 else
00475 newIDs.append(evid);
00476 }
00477 if (omit)
00478 {
00479 for (QStringList::ConstIterator i = newIDs.begin(); i != newIDs.end(); ++i)
00480 ignoreIDs.append(*i);
00481 }
00482 }
00483 else
00484 {
00485 omit = (ignoreIDs.find(item->eventID()) != ignoreIDs.end());
00486 if (!omit)
00487 ignoreIDs.append(item->eventID());
00488 if (item->operation() == UndoItem::EDIT)
00489 ignoreIDs.append(item->oldEventID());
00490 }
00491 if (!omit)
00492 ids.append(item->id());
00493
00494 }
00495
00496 return ids;
00497 }
00498
00499
00500
00501
00502 void Undo::emitChanged()
00503 {
00504 if (mInstance)
00505 mInstance->emitChanged(actionText(UNDO), actionText(REDO));
00506 }
00507
00508
00509
00510
00511 UndoItem* Undo::getItem(int id, Undo::Type type)
00512 {
00513 List* list = (type == UNDO) ? &mUndoList : (type == REDO) ? &mRedoList : 0;
00514 if (list)
00515 {
00516 for (Iterator it = list->begin(); it != list->end(); ++it)
00517 {
00518 if ((*it)->id() == id)
00519 return *it;
00520 }
00521 }
00522 return 0;
00523 }
00524
00525
00526
00527
00528 Undo::Iterator Undo::findItem(int id, Undo::Type type)
00529 {
00530 List* list = (type == UNDO) ? &mUndoList : &mRedoList;
00531 Iterator it;
00532 for (it = list->begin(); it != list->end(); ++it)
00533 {
00534 if ((*it)->id() == id)
00535 break;
00536 }
00537 return it;
00538 }
00539
00540
00541
00542
00543
00544
00545 int UndoItem::mLastId = 0;
00546 UndoItem::Error UndoItem::mRestoreError;
00547 UndoItem::Warning UndoItem::mRestoreWarning;
00548 int UndoItem::mRestoreWarningCount;
00549
00550
00551
00552
00553
00554 UndoItem::UndoItem(Undo::Type type)
00555 : mId(0),
00556 mType(type)
00557 {
00558 if (type != Undo::NONE)
00559 {
00560 mId = ++mLastId;
00561 if (mId < 0)
00562 mId = mLastId = 1;
00563 Undo::add(this, (mType == Undo::UNDO));
00564 }
00565 }
00566
00567
00568
00569
00570
00571 UndoItem::~UndoItem()
00572 {
00573 if (mType != Undo::NONE)
00574 Undo::remove(this, (mType == Undo::UNDO));
00575 }
00576
00577
00578
00579
00580 QString UndoItem::description(const KAEvent& event) const
00581 {
00582 return (mCalendar == KAEvent::TEMPLATE) ? event.templateName() : AlarmText::summary(event);
00583 }
00584
00585
00586
00587
00588 QString UndoItem::addDeleteActionText(KAEvent::Status calendar, bool add)
00589 {
00590 switch (calendar)
00591 {
00592 case KAEvent::ACTIVE:
00593 if (add)
00594 return i18n("Action to create a new alarm", "New alarm");
00595 else
00596 return i18n("Action to delete an alarm", "Delete alarm");
00597 case KAEvent::TEMPLATE:
00598 if (add)
00599 return i18n("Action to create a new alarm template", "New template");
00600 else
00601 return i18n("Action to delete an alarm template", "Delete template");
00602 case KAEvent::EXPIRED:
00603 return i18n("Delete expired alarm");
00604 default:
00605 break;
00606 }
00607 return QString::null;
00608 }
00609
00610
00611
00612
00613
00614
00615
00616 template <class T>
00617 UndoMulti<T>::UndoMulti(Undo::Type type, const QValueList<KAEvent>& events)
00618 : UndoMultiBase(type)
00619 {
00620 for (QValueList<KAEvent>::ConstIterator it = events.begin(); it != events.end(); ++it)
00621 mUndos.append(new T(Undo::NONE, *it));
00622 }
00623
00624 UndoMultiBase::~UndoMultiBase()
00625 {
00626 for (Undo::List::Iterator it = mUndos.begin(); it != mUndos.end(); ++it)
00627 delete *it;
00628 }
00629
00630
00631
00632
00633
00634
00635
00636 template <class T>
00637 UndoItem* UndoMulti<T>::restore()
00638 {
00639 Undo::List newUndos;
00640 for (Undo::List::Iterator it = mUndos.begin(); it != mUndos.end(); ++it)
00641 {
00642 UndoItem* undo = (*it)->restore();
00643 if (undo)
00644 newUndos.append(undo);
00645 }
00646 if (newUndos.isEmpty())
00647 return 0;
00648
00649
00650 return createRedo(newUndos);
00651 }
00652
00653
00654
00655
00656
00657
00658
00659
00660 template <class T>
00661 bool UndoMulti<T>::deleteID(const QString& id)
00662 {
00663 for (Undo::List::Iterator it = mUndos.begin(); it != mUndos.end(); ++it)
00664 {
00665 UndoItem* item = *it;
00666 if (item->eventID() == id)
00667 {
00668
00669 mUndos.remove(it);
00670 if (mUndos.count() == 1)
00671 {
00672
00673
00674 replaceWith(item);
00675 return true;
00676 }
00677 else
00678 {
00679 delete item;
00680 return false;
00681 }
00682 }
00683 }
00684 return false;
00685 }
00686
00687
00688
00689
00690
00691
00692
00693 UndoAdd::UndoAdd(Undo::Type type, const KAEvent& event)
00694 : UndoItem(type),
00695 mEventID(event.id())
00696 {
00697 setCalendar(KAEvent::uidStatus(mEventID));
00698 mDescription = UndoItem::description(event);
00699 }
00700
00701 UndoAdd::UndoAdd(Undo::Type type, const KAEvent& event, KAEvent::Status cal)
00702 : UndoItem(type),
00703 mEventID(KAEvent::uid(event.id(), cal))
00704 {
00705 setCalendar(cal);
00706 mDescription = UndoItem::description(event);
00707 }
00708
00709
00710
00711
00712
00713
00714 UndoItem* UndoAdd::doRestore(bool setArchive)
00715 {
00716
00717 kdDebug(5950) << "UndoAdd::doRestore(" << mEventID << ")\n";
00718 const KCal::Event* kcalEvent = AlarmCalendar::getEvent(mEventID);
00719 if (!kcalEvent)
00720 {
00721 mRestoreError = ERR_NOT_FOUND;
00722 return 0;
00723 }
00724 KAEvent event(*kcalEvent);
00725
00726
00727
00728 UndoItem* undo = createRedo(event);
00729
00730 switch (calendar())
00731 {
00732 case KAEvent::ACTIVE:
00733 if (setArchive)
00734 event.setArchive();
00735
00736 if (KAlarm::deleteEvent(event, true) == KAlarm::UPDATE_KORG_ERR)
00737 {
00738 mRestoreWarning = WARN_KORG_DELETE;
00739 ++mRestoreWarningCount;
00740 }
00741 break;
00742 case KAEvent::TEMPLATE:
00743 KAlarm::deleteTemplate(event);
00744 break;
00745 case KAEvent::EXPIRED:
00746 KAlarm::deleteEvent(event);
00747 break;
00748 default:
00749 delete undo;
00750 mRestoreError = ERR_PROG;
00751 return 0;
00752 }
00753 return undo;
00754 }
00755
00756
00757
00758
00759 UndoItem* UndoAdd::createRedo(const KAEvent& event)
00760 {
00761 Undo::Type t = (type() == Undo::UNDO) ? Undo::REDO : (type() == Undo::REDO) ? Undo::UNDO : Undo::NONE;
00762 return new UndoDelete(t, event);
00763 }
00764
00765
00766
00767
00768 QString UndoAdd::actionText() const
00769 {
00770 return addDeleteActionText(calendar(), (type() == Undo::UNDO));
00771 }
00772
00773
00774
00775
00776
00777
00778
00779 UndoEdit::UndoEdit(Undo::Type type, const KAEvent& oldEvent, const QString& newEventID, const QString& description)
00780 : UndoItem(type),
00781 mOldEvent(new KAEvent(oldEvent)),
00782 mNewEventID(newEventID),
00783 mDescription(description)
00784 {
00785 setCalendar(KAEvent::uidStatus(mNewEventID));
00786 }
00787
00788 UndoEdit::~UndoEdit()
00789 {
00790 delete mOldEvent;
00791 }
00792
00793
00794
00795
00796
00797
00798 UndoItem* UndoEdit::restore()
00799 {
00800 kdDebug(5950) << "UndoEdit::restore(" << mNewEventID << ")\n";
00801
00802 const KCal::Event* kcalEvent = AlarmCalendar::getEvent(mNewEventID);
00803 if (!kcalEvent)
00804 {
00805 mRestoreError = ERR_NOT_FOUND;
00806 return 0;
00807 }
00808 KAEvent newEvent(*kcalEvent);
00809
00810
00811 Undo::Type t = (type() == Undo::UNDO) ? Undo::REDO : (type() == Undo::REDO) ? Undo::UNDO : Undo::NONE;
00812 UndoItem* undo = new UndoEdit(t, newEvent, mOldEvent->id(), mDescription);
00813
00814 switch (calendar())
00815 {
00816 case KAEvent::ACTIVE:
00817 if (KAlarm::modifyEvent(newEvent, *mOldEvent, 0) == KAlarm::UPDATE_KORG_ERR)
00818 {
00819 mRestoreWarning = WARN_KORG_MODIFY;
00820 ++mRestoreWarningCount;
00821 }
00822 break;
00823 case KAEvent::TEMPLATE:
00824 KAlarm::updateTemplate(*mOldEvent, 0);
00825 break;
00826 case KAEvent::EXPIRED:
00827 default:
00828 delete undo;
00829 mRestoreError = ERR_PROG;
00830 return 0;
00831 }
00832 return undo;
00833 }
00834
00835
00836
00837
00838 QString UndoEdit::actionText() const
00839 {
00840 switch (calendar())
00841 {
00842 case KAEvent::ACTIVE:
00843 return i18n("Action to edit an alarm", "Edit alarm");
00844 case KAEvent::TEMPLATE:
00845 return i18n("Action to edit an alarm template", "Edit template");
00846 default:
00847 break;
00848 }
00849 return QString::null;
00850 }
00851
00852
00853
00854
00855
00856
00857
00858 UndoDelete::UndoDelete(Undo::Type type, const KAEvent& event)
00859 : UndoItem(type),
00860 mEvent(new KAEvent(event))
00861 {
00862 setCalendar(KAEvent::uidStatus(mEvent->id()));
00863 }
00864
00865 UndoDelete::~UndoDelete()
00866 {
00867 delete mEvent;
00868 }
00869
00870
00871
00872
00873
00874
00875 UndoItem* UndoDelete::restore()
00876 {
00877 kdDebug(5950) << "UndoDelete::restore(" << mEvent->id() << ")\n";
00878
00879 switch (calendar())
00880 {
00881 case KAEvent::ACTIVE:
00882 if (mEvent->toBeArchived())
00883 {
00884
00885 mEvent->setUid(KAEvent::EXPIRED);
00886 switch (KAlarm::reactivateEvent(*mEvent, 0, true))
00887 {
00888 case KAlarm::UPDATE_KORG_ERR:
00889 mRestoreWarning = WARN_KORG_ADD;
00890 ++mRestoreWarningCount;
00891 break;
00892 case KAlarm::UPDATE_ERROR:
00893 mRestoreError = ERR_EXPIRED;
00894 return 0;
00895 case KAlarm::UPDATE_OK:
00896 break;
00897 }
00898 }
00899 else
00900 {
00901 switch (KAlarm::addEvent(*mEvent, 0, true))
00902 {
00903 case KAlarm::UPDATE_KORG_ERR:
00904 mRestoreWarning = WARN_KORG_ADD;
00905 ++mRestoreWarningCount;
00906 break;
00907 case KAlarm::UPDATE_ERROR:
00908 mRestoreError = ERR_CREATE;
00909 return 0;
00910 case KAlarm::UPDATE_OK:
00911 break;
00912 }
00913 }
00914 break;
00915 case KAEvent::TEMPLATE:
00916 if (!KAlarm::addTemplate(*mEvent, 0))
00917 {
00918 mRestoreError = ERR_CREATE;
00919 return 0;
00920 }
00921 break;
00922 case KAEvent::EXPIRED:
00923 if (!KAlarm::addExpiredEvent(*mEvent))
00924 {
00925 mRestoreError = ERR_CREATE;
00926 return 0;
00927 }
00928 break;
00929 default:
00930 mRestoreError = ERR_PROG;
00931 return 0;
00932 }
00933
00934
00935 return createRedo(*mEvent);
00936 }
00937
00938
00939
00940
00941 UndoItem* UndoDelete::createRedo(const KAEvent& event)
00942 {
00943 Undo::Type t = (type() == Undo::UNDO) ? Undo::REDO : (type() == Undo::REDO) ? Undo::UNDO : Undo::NONE;
00944 return new UndoAdd(t, event);
00945 }
00946
00947
00948
00949
00950 QString UndoDelete::actionText() const
00951 {
00952 return addDeleteActionText(calendar(), (type() == Undo::REDO));
00953 }
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964 UndoItem* UndoDeletes::createRedo(Undo::List& undos)
00965 {
00966 Undo::Type t = (type() == Undo::UNDO) ? Undo::REDO : (type() == Undo::REDO) ? Undo::UNDO : Undo::NONE;
00967 return new UndoDeletes(t, undos);
00968 }
00969
00970
00971
00972
00973 QString UndoDeletes::actionText() const
00974 {
00975 if (mUndos.isEmpty())
00976 return QString::null;
00977 for (Undo::List::ConstIterator it = mUndos.begin(); it != mUndos.end(); ++it)
00978 {
00979 switch ((*it)->calendar())
00980 {
00981 case KAEvent::ACTIVE:
00982 return i18n("Delete multiple alarms");
00983 case KAEvent::TEMPLATE:
00984 return i18n("Delete multiple templates");
00985 case KAEvent::EXPIRED:
00986 break;
00987 default:
00988 return QString::null;
00989 }
00990 }
00991 return i18n("Delete multiple expired alarms");
00992 }
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005 UndoItem* UndoReactivate::restore()
01006 {
01007 kdDebug(5950) << "UndoReactivate::restore()\n";
01008
01009 switch (calendar())
01010 {
01011 case KAEvent::ACTIVE:
01012 break;
01013 default:
01014 mRestoreError = ERR_PROG;
01015 return 0;
01016 }
01017 return UndoAdd::doRestore(true);
01018 }
01019
01020
01021
01022
01023 UndoItem* UndoReactivate::createRedo(const KAEvent& event)
01024 {
01025 Undo::Type t = (type() == Undo::UNDO) ? Undo::REDO : (type() == Undo::REDO) ? Undo::UNDO : Undo::NONE;
01026 return new UndoDeactivate(t, event);
01027 }
01028
01029
01030
01031
01032 QString UndoReactivate::actionText() const
01033 {
01034 return i18n("Reactivate alarm");
01035 }
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048 UndoItem* UndoDeactivate::restore()
01049 {
01050 kdDebug(5950) << "UndoDeactivate::restore()\n";
01051
01052 switch (calendar())
01053 {
01054 case KAEvent::ACTIVE:
01055 break;
01056 default:
01057 mRestoreError = ERR_PROG;
01058 return 0;
01059 }
01060
01061 return UndoDelete::restore();
01062 }
01063
01064
01065
01066
01067 UndoItem* UndoDeactivate::createRedo(const KAEvent& event)
01068 {
01069 Undo::Type t = (type() == Undo::UNDO) ? Undo::REDO : (type() == Undo::REDO) ? Undo::UNDO : Undo::NONE;
01070 return new UndoReactivate(t, event);
01071 }
01072
01073
01074
01075
01076 QString UndoDeactivate::actionText() const
01077 {
01078 return i18n("Reactivate alarm");
01079 }
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090 UndoItem* UndoReactivates::createRedo(Undo::List& undos)
01091 {
01092 Undo::Type t = (type() == Undo::UNDO) ? Undo::REDO : (type() == Undo::REDO) ? Undo::UNDO : Undo::NONE;
01093 return new UndoReactivates(t, undos);
01094 }
01095
01096
01097
01098
01099 QString UndoReactivates::actionText() const
01100 {
01101 return i18n("Reactivate multiple alarms");
01102 }