src/xml/event.h

   1 #ifndef SEEN_INKSCAPE_XML_SP_REPR_ACTION_H
   2 #define SEEN_INKSCAPE_XML_SP_REPR_ACTION_H
   3
   4 #include <glib/gtypes.h>
   5 #include <glib/gquark.h>
   6 #include <glibmm/ustring.h>
   7
   8 #include <iterator>
   9 #include "util/share.h"
  10 #include "util/forward-pointer-iterator.h"
  11 #include "gc-managed.h"
  12 #include "xml/node.h"
  13
  14 namespace Inkscape {
  15 namespace XML {
  16
  17 class Node;
  18 class NodeObserver;
  19
  20 enum EventType {
  21         EVENT_ADD,
  22         EVENT_DEL,
  23         EVENT_CHG_ATTR,
  24         EVENT_CHG_CONTENT,
  25         EVENT_CHG_ORDER
  26 };
  27
  28 class Event
  29 : public Inkscape::GC::Managed<Inkscape::GC::SCANNED, Inkscape::GC::MANUAL>
  30 {
  31 public:
  32
  33         virtual ~Event() {}
  34
  35         Event *next;
  36         int serial;
  37         Node *repr;
  38
  39         struct IteratorStrategy {
  40                 static Event const *next(Event const *action) {
  41                         return action->next;
  42                 }
  43         };
  44
  45         typedef Inkscape::Util::ForwardPointerIterator<Event, IteratorStrategy> Iterator;
  46         typedef Inkscape::Util::ForwardPointerIterator<Event const, IteratorStrategy> ConstIterator;
  47
  48         Event *optimizeOne() { return _optimizeOne(); }
  49         void undoOne(NodeObserver &observer) const {
  50                 _undoOne(observer);
  51         }
  52         void replayOne(NodeObserver &observer) const {
  53                 _replayOne(observer);
  54         }
  55
  56 protected:
  57         Event(Node *r, Event *n)
  58         : next(n), serial(_next_serial++), repr(r) {}
  59
  60         virtual Event *_optimizeOne()=0;
  61         virtual void _undoOne(NodeObserver &) const=0;
  62         virtual void _replayOne(NodeObserver &) const=0;
  63
  64 private:
  65         static int _next_serial;
  66 };
  67
  68 class EventAdd : public Event {
  69 public:
  70         EventAdd(Node *repr, Node *c, Node *rr, Event *next)
  71         : Event(repr, next), child(c), ref(rr) {}
  72
  73         Node *child;
  74         Node *ref;
  75
  76 private:
  77         Event *_optimizeOne();
  78         void _undoOne(NodeObserver &observer) const;
  79         void _replayOne(NodeObserver &observer) const;
  80 };
  81
  82 class EventDel : public Event {
  83 public:
  84         EventDel(Node *repr, Node *c, Node *rr, Event *next)
  85         : Event(repr, next), child(c), ref(rr) {}
  86
  87         Node *child;
  88         Node *ref;
  89
  90 private:
  91         Event *_optimizeOne();
  92         void _undoOne(NodeObserver &observer) const;
  93         void _replayOne(NodeObserver &observer) const;
  94 };
  95
  96 class EventChgAttr : public Event {
  97 public:
  98         EventChgAttr(Node *repr, GQuark k,
  99                      Inkscape::Util::ptr_shared<char> ov,
 100                      Inkscape::Util::ptr_shared<char> nv,
 101                      Event *next)
 102         : Event(repr, next), key(k),
 103           oldval(ov), newval(nv) {}
 104
 105         GQuark key;
 106         Inkscape::Util::ptr_shared<char> oldval;
 107         Inkscape::Util::ptr_shared<char> newval;
 108
 109 private:
 110         Event *_optimizeOne();
 111         void _undoOne(NodeObserver &observer) const;
 112         void _replayOne(NodeObserver &observer) const;
 113 };
 114
 115 class EventChgContent : public Event {
 116 public:
 117         EventChgContent(Node *repr,
 118                         Inkscape::Util::ptr_shared<char> ov,
 119                         Inkscape::Util::ptr_shared<char> nv,
 120                         Event *next)
 121         : Event(repr, next), oldval(ov), newval(nv) {}
 122
 123         Inkscape::Util::ptr_shared<char> oldval;
 124         Inkscape::Util::ptr_shared<char> newval;
 125
 126 private:
 127         Event *_optimizeOne();
 128         void _undoOne(NodeObserver &observer) const;
 129         void _replayOne(NodeObserver &observer) const;
 130 };
 131
 132 class EventChgOrder : public Event {
 133 public:
 134         EventChgOrder(Node *repr, Node *c, Node *orr, Node *nrr, Event *next)
 135         : Event(repr, next), child(c),
 136           oldref(orr), newref(nrr) {}
 137
 138         Node *child;
 139         Node *oldref, *newref;
 140
 141 private:
 142         Event *_optimizeOne();
 143         void _undoOne(NodeObserver &observer) const;
 144         void _replayOne(NodeObserver &observer) const;
 145 };
 146
 147 }
 148 }
 149
 150 #endif