event.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
 * Authors:
 *   Unknown author(s)
 *   Krzysztof Kosiński <tweenk.pl@gmail.com> (documentation)
 *
 * Copyright (C) 2018 Authors
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#ifndef SEEN_INKSCAPE_XML_SP_REPR_ACTION_H
#define SEEN_INKSCAPE_XML_SP_REPR_ACTION_H
 
typedef unsigned int GQuark;
#include <glibmm/ustring.h>
 
#include <iterator>
#include "util/share.h"
#include "util/forward-pointer-iterator.h"
#include "inkgc/gc-managed.h"
#include "xml/node.h"
 
namespace Inkscape {
namespace XML {
 
// enum EventType {
//     EVENT_ADD, ///< Child added
//     EVENT_DEL, ///< Child removed
//     EVENT_CHG_ATTR, ///< Attribute changed
//     EVENT_CHG_CONTENT, ///< Content changed
//     EVENT_CHG_ORDER ///< Order of children changed
// };
 
class Event
: public Inkscape::GC::Managed<Inkscape::GC::SCANNED, Inkscape::GC::MANUAL>
{
public:        
    virtual ~Event() = default;
 
    Event *next;
    int serial;
    Node *repr;
 
    struct IteratorStrategy {
        static Event const *next(Event const *action) {
            return action->next;
        }
    };
 
    typedef Inkscape::Util::ForwardPointerIterator<Event, IteratorStrategy> Iterator;
    typedef Inkscape::Util::ForwardPointerIterator<Event const, IteratorStrategy> ConstIterator;
 
    Event *optimizeOne() { return _optimizeOne(); }
    void undoOne(NodeObserver &observer) const {
        _undoOne(observer);
    }
    void replayOne(NodeObserver &observer) const {
        _replayOne(observer);
    }
 
protected:
    Event(Node *r, Event *n)
    : next(n), serial(_next_serial++), repr(r) {}
 
    virtual Event *_optimizeOne()=0;
    virtual void _undoOne(NodeObserver &) const=0;
    virtual void _replayOne(NodeObserver &) const=0;
 
private:
    static int _next_serial;
};
 
class EventAdd : public Event {
public:
    EventAdd(Node *repr, Node *c, Node *rr, Event *next)
    : Event(repr, next), child(c), ref(rr) {}
 
    Node *child;
    Node *ref;
 
private:
    Event *_optimizeOne() override;
    void _undoOne(NodeObserver &observer) const override;
    void _replayOne(NodeObserver &observer) const override;
};
 
class EventDel : public Event {
public:
    EventDel(Node *repr, Node *c, Node *rr, Event *next)
    : Event(repr, next), child(c), ref(rr) {}
 
    Node *child;
    Node *ref;
 
private:
    Event *_optimizeOne() override;
    void _undoOne(NodeObserver &observer) const override;
    void _replayOne(NodeObserver &observer) const override;
};
 
class EventChgAttr : public Event {
public:
    EventChgAttr(Node *repr, GQuark k,
                 Inkscape::Util::ptr_shared ov,
                 Inkscape::Util::ptr_shared nv,
                 Event *next)
    : Event(repr, next), key(k),
      oldval(ov), newval(nv) {}
 
    GQuark key;
    Inkscape::Util::ptr_shared oldval;
    Inkscape::Util::ptr_shared newval;
 
private:
    Event *_optimizeOne() override;
    void _undoOne(NodeObserver &observer) const override;
    void _replayOne(NodeObserver &observer) const override;
};
 
class EventChgContent : public Event {
public:
    EventChgContent(Node *repr,
                    Inkscape::Util::ptr_shared ov,
                    Inkscape::Util::ptr_shared nv,
                    Event *next)
    : Event(repr, next), oldval(ov), newval(nv) {}
 
    Inkscape::Util::ptr_shared oldval;
    Inkscape::Util::ptr_shared newval;
 
private:
    Event *_optimizeOne() override;
    void _undoOne(NodeObserver &observer) const override;
    void _replayOne(NodeObserver &observer) const override;
};
 
class EventChgOrder : public Event {
public:
    EventChgOrder(Node *repr, Node *c, Node *orr, Node *nrr, Event *next)
    : Event(repr, next), child(c),
      oldref(orr), newref(nrr) {}
 
    Node *child;
    Node *oldref;
    Node *newref;
 
private:
    Event *_optimizeOne() override;
    void _undoOne(NodeObserver &observer) const override;
    void _replayOne(NodeObserver &observer) const override;
};
 
class EventChgElementName : public Event {
public:
    EventChgElementName(Node* repr, GQuark old_name, GQuark new_name, Event* next)
        : Event(repr, next), old_name(old_name), new_name(new_name) {}
 
    GQuark old_name;
    GQuark new_name;
 
private:
    Event* _optimizeOne() override;
    void _undoOne(NodeObserver& observer) const override;
    void _replayOne(NodeObserver& observer) const override;
};
 
}
}
 
#endif
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :