node.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
#ifndef SEEN_INKSCAPE_XML_NODE_H
#define SEEN_INKSCAPE_XML_NODE_H
 
#include <vector>
 
#include <2geom/point.h>
 
#include "gc-anchored.h"
#include "inkgc/gc-alloc.h"
#include "node-iterators.h"
#include "util/const_char_ptr.h"
 
class SVGLength;
 
namespace Inkscape {
namespace XML {
 
class AttributeRecord;
struct Document;
class NodeObserver;
 
using AttributeVector = std::vector<AttributeRecord, Inkscape::GC::Alloc<AttributeRecord>>;
 
enum class NodeType
{
    DOCUMENT_NODE, 
    ELEMENT_NODE,  
    TEXT_NODE, 
    COMMENT_NODE, 
    PI_NODE       
};
 
// careful; GC::Anchored should only appear once in the inheritance
// hierarchy; otherwise there will be leaks
 
class Node : public Inkscape::GC::Anchored {
public:
    Node() = default;
    ~Node() override = default;
 
    virtual NodeType type() const = 0;
 
    virtual char const *name() const = 0;
    virtual int code() const = 0;
 
    virtual unsigned position() const = 0;
 
    virtual unsigned childCount() const = 0;
 
    virtual char const *content() const = 0;
 
    virtual char const *attribute(char const *key) const = 0;
 
    virtual const AttributeVector & attributeList() const=0;
 
    virtual bool matchAttributeName(char const *partial_name) const = 0;
 
    virtual void setPosition(int pos) = 0;
 
    virtual void setContent(char const *value) = 0;
 
 
    void setAttribute(Util::const_char_ptr key, Util::const_char_ptr value);
 
    bool copyAttribute(Util::const_char_ptr key, Node const *source_node, bool remove_if_empty = false);
 
    bool getAttributeBoolean(Util::const_char_ptr key, bool default_value = false) const;
 
    int getAttributeInt(Util::const_char_ptr key, int default_value = 0) const;
 
    double getAttributeDouble(Util::const_char_ptr key, double default_value = 0.0) const;
 
    bool setAttributeBoolean(Util::const_char_ptr key, bool val);
 
    bool setAttributeInt(Util::const_char_ptr key, int val);
 
    bool setAttributeCssDouble(Util::const_char_ptr key, double val);
 
    bool setAttributeSvgDouble(Util::const_char_ptr key, double val);
 
    bool setAttributeSvgNonDefaultDouble(Util::const_char_ptr key,
                                         double val, double default_value);
 
    bool setAttributeSvgLength(Util::const_char_ptr key, SVGLength const &val);
 
    bool setAttributePoint(Util::const_char_ptr key, Geom::Point const &val);
 
    Geom::Point getAttributePoint(Util::const_char_ptr key, Geom::Point default_value = {}) const;
 
    void setAttributeOrRemoveIfEmpty(Inkscape::Util::const_char_ptr key, Inkscape::Util::const_char_ptr value);
 
    void removeAttribute(Inkscape::Util::const_char_ptr key) { this->setAttributeImpl(key.data(), nullptr); }
 
 
    virtual void setCodeUnsafe(int code) = 0;
 
    virtual Document *document() = 0;
    virtual Document const *document() const = 0;
 
 
    virtual Node *root() = 0;
    virtual Node const *root() const = 0;
 
 
    virtual Node *parent() = 0;
    virtual Node const *parent() const = 0;
 
 
    virtual Node *next() = 0;
    virtual Node const *next() const = 0;
    virtual Node *prev() = 0;
    virtual Node const *prev() const = 0;
 
 
    virtual Node *firstChild() = 0;
    virtual Node const *firstChild() const = 0;
 
 
    virtual Node *lastChild() = 0;
    virtual Node const *lastChild() const = 0;
 
 
    virtual Node *nthChild(unsigned index) = 0;
    virtual Node const *nthChild(unsigned index) const = 0;
 
    virtual Node *duplicate(Document *doc) const = 0;
 
    virtual void addChild(Node *child, Node *after) = 0;
 
    void addChildAtPos(Node *child, unsigned pos)
    {
        Node *after = (pos == 0) ? nullptr : nthChild(pos - 1);
        addChild(child, after);
    }
 
    virtual void appendChild(Node *child) = 0;
 
    virtual void removeChild(Node *child) = 0;
 
    virtual void changeOrder(Node *child, Node *after) = 0;
 
    virtual void cleanOriginal(Node *src, char const *key) = 0;
 
    virtual bool equal(Node const *other, bool recursive, bool skip_ids = false) = 0;
    virtual void mergeFrom(Node const *src, char const *key, bool extension = false, bool clean = false) = 0;
 
    virtual void addObserver(NodeObserver &observer) = 0;
    virtual void removeObserver(NodeObserver &observer) = 0;
    virtual void synthesizeEvents(NodeObserver &observer) = 0;
 
    virtual void addSubtreeObserver(NodeObserver &observer) = 0;
 
    virtual void removeSubtreeObserver(NodeObserver &observer) = 0;
 
    virtual void recursivePrintTree(unsigned level) = 0;
 
    using iterator = Inkscape::XML::NodeSiblingIterator;
 
    iterator begin() { return iterator(this->firstChild()); }
    iterator end() { return iterator(nullptr); }
 
    bool operator==(const std::string &name) const { return this->name() == name; }
 
    template <typename T>
    Node *findChildPath(T list)
    {
        return findChildPath(list.cbegin(), list.cend());
    }
 
    template <typename iterT>
    Node *findChildPath(iterT itr, iterT end)
    {
        if (itr == end) {
            return this;
        }
 
        for (auto &child : *this) {
            if (child == *itr) {
                auto found = child.findChildPath(std::next(itr), end);
                if (found != nullptr) {
                    return found;
                }
            }
        }
 
        return nullptr;
    }
 
protected:
    Node(Node const &)
        : Anchored()
    {}
 
    virtual void setAttributeImpl(char const *key, char const *value) = 0;
};
 
} // namespace XML
} // namespace Inkscape
 
#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 :