sp-object.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
#ifndef SP_OBJECT_H_SEEN
#define SP_OBJECT_H_SEEN
 
/*
 * Authors:
 *   Lauris Kaplinski <lauris@kaplinski.com>
 *   Jon A. Cruz <jon@joncruz.org>
 *   Abhishek Sharma
 *   Adrian Boguszewski
 *
 * Copyright (C) 1999-2016 authors
 * Copyright (C) 2001-2002 Ximian, Inc.
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#include <set>
#include <glibmm/ustring.h>
#include "util/const_char_ptr.h"
#include "xml/node-observer.h"
/* SPObject flags */
 
class SPObject;
 
/* Async modification flags */
#define SP_OBJECT_MODIFIED_FLAG (1 << 0)
#define SP_OBJECT_CHILD_MODIFIED_FLAG (1 << 1)
#define SP_OBJECT_PARENT_MODIFIED_FLAG (1 << 2)
#define SP_OBJECT_STYLE_MODIFIED_FLAG (1 << 3)
#define SP_OBJECT_VIEWPORT_MODIFIED_FLAG (1 << 4)
#define SP_OBJECT_USER_MODIFIED_FLAG_A (1 << 5)
#define SP_OBJECT_USER_MODIFIED_FLAG_B (1 << 6)
#define SP_OBJECT_STYLESHEET_MODIFIED_FLAG (1 << 7)
 
/* Convenience */
#define SP_OBJECT_FLAGS_ALL 0xff
 
// Tags that can be passed along with other "modified" flags.
// Client code can use them to track senders of modification requests.
// Tags themselves do not signify any modification to the object(s).
#define SP_OBJECT_USER_MODIFIED_TAG_1 (1 << 8)
#define SP_OBJECT_USER_MODIFIED_TAG_2 (1 << 9)
#define SP_OBJECT_USER_MODIFIED_TAG_3 (1 << 10)
#define SP_OBJECT_USER_MODIFIED_TAG_4 (1 << 11)
#define SP_OBJECT_USER_MODIFIED_TAG_5 (1 << 12)
#define SP_OBJECT_USER_MODIFIED_TAG_6 (1 << 13)
#define SP_OBJECT_USER_MODIFIED_TAG_7 (1 << 14)
#define SP_OBJECT_USER_MODIFIED_TAG_8 (1 << 15)
 
#define SP_OBJECT_USER_TAGS_ALL 0xff00
 
/* Flags that mark object as modified */
/* Object, Child, Style, Viewport, User */
#define SP_OBJECT_MODIFIED_STATE (SP_OBJECT_FLAGS_ALL & ~(SP_OBJECT_PARENT_MODIFIED_FLAG))
 
/* Flags that will propagate downstreams */
/* Parent, Style, Viewport, User */
#define SP_OBJECT_MODIFIED_CASCADE ((SP_OBJECT_FLAGS_ALL | SP_OBJECT_USER_TAGS_ALL) & ~(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))
inline unsigned cascade_flags(unsigned flags)
{
    // Unset object-modified and child-modified, set parent-modified if object-modified.
    static_assert(SP_OBJECT_PARENT_MODIFIED_FLAG == SP_OBJECT_MODIFIED_FLAG << 2);
    return (flags & SP_OBJECT_MODIFIED_CASCADE) | (flags & SP_OBJECT_MODIFIED_FLAG) << 2;
}
 
/* Write flags */
#define SP_OBJECT_WRITE_BUILD (1 << 0)
#define SP_OBJECT_WRITE_EXT (1 << 1)
#define SP_OBJECT_WRITE_ALL (1 << 2)
#define SP_OBJECT_WRITE_NO_CHILDREN (1 << 3)
 
#include <vector>
#include <cassert>
#include <cstddef>
#include <boost/intrusive/list.hpp>
#include <2geom/point.h> // Used for dpi only
#include <sigc++/connection.h>
#include <sigc++/functors/slot.h>
#include <sigc++/signal.h>
#include "util/forward-pointer-iterator.h"
#include "tags.h"
#include "version.h"
 
enum class SPAttr;
 
class SPCSSAttr;
class SPStyle;
 
namespace Inkscape::XML { class Node; struct Document; }
 
struct SPCtx
{
    unsigned int flags;
};
 
enum
{
    SP_XML_SPACE_DEFAULT,
    SP_XML_SPACE_PRESERVE
};
 
class SPDocument;
 
class SPIXmlSpace {
public:    
    SPIXmlSpace(): set(0), value(SP_XML_SPACE_DEFAULT) {};
    unsigned int set : 1;
    unsigned int value : 1;
};
 
/*
 * Refcounting
 *
 * Owner is here for debug reasons, you can set it to NULL safely
 * Ref should return object, NULL is error, unref return always NULL
 */
 
SPObject *sp_object_ref(SPObject *object, SPObject *owner=nullptr);
 
SPObject *sp_object_unref(SPObject *object, SPObject *owner=nullptr);
 
class SPObject : private Inkscape::XML::NodeObserver
{
public:
    enum CollectionPolicy
    {
        COLLECT_WITH_PARENT,
        ALWAYS_COLLECT
    };
    enum class LinkedObjectNature
    {
        DEPENDENT = -1,
        ANY = 0,
        DEPENDENCY = 1,
    };
 
    SPObject();
    SPObject(SPObject const &) = delete;
    SPObject &operator=(SPObject const &) = delete;
    ~SPObject() override;
    virtual int tag() const { return tag_of<decltype(*this)>; }
 
    unsigned int cloned : 1;
    SPObject *clone_original{nullptr};
    unsigned int uflags : 16;
    unsigned int mflags : 16;
    SPIXmlSpace xml_space;
    Glib::ustring lang;
    unsigned int hrefcount{0};        /* number of xlink:href references */
    unsigned int _total_hrefcount{0}; /* our hrefcount + total descendants */
    SPDocument *document{nullptr};    /* Document we are part of */
    SPObject *parent{nullptr};        /* Our parent (only one allowed) */
 
private:
    char *id{nullptr};                  /* Our very own unique id */
    Inkscape::XML::Node *repr{nullptr}; /* Our xml representation */
 
public:
    int refCount{1};
    std::list<SPObject *> hrefList;
 
    char const* getId() const;
 
    void getIds(std::set<std::string> &ret) const;
 
    std::string getUrl() const;
 
//protected:
    Inkscape::XML::Node * getRepr();
 
    Inkscape::XML::Node const* getRepr() const;
 
public:
 
    void releaseReferences();
 
    sigc::connection connectRelease(sigc::slot<void (SPObject *)> slot) {
        return _release_signal.connect(slot);
    }
 
    SPStyle *style;
 
    SPStyle *context_style;
 
    struct ParentIteratorStrategy {
        static SPObject const *next(SPObject const *object) {
            return object->parent;
        }
    };
 
    typedef Inkscape::Util::ForwardPointerIterator<SPObject, ParentIteratorStrategy> ParentIterator;
    typedef Inkscape::Util::ForwardPointerIterator<SPObject const, ParentIteratorStrategy> ConstParentIterator;
 
    bool isSiblingOf(SPObject const *object) const {
        if (object == nullptr) return false;
        return this->parent && this->parent == object->parent;
    }
 
    virtual void getLinked(std::vector<SPObject *> &objects, LinkedObjectNature direction = LinkedObjectNature::ANY) const;
 
    std::vector<SPObject *> getLinked(LinkedObjectNature direction = LinkedObjectNature::ANY) const {
        std::vector<SPObject *> ret;
        getLinked(ret, direction);
        return ret;
    }
 
    bool isAncestorOf(SPObject const *object) const;
 
    SPObject const *nearestCommonAncestor(SPObject const *object) const;
 
    SPObject const * getTopAncestorNonLayer() const;
 
    /* Returns next object in sibling list or NULL. */
    SPObject *getNext();
 
    SPObject *getPrev();
 
    bool hasChildren() const { return ( children.size() > 0 ); }
 
    SPObject *firstChild() { return children.empty() ? nullptr : &children.front(); }
    SPObject const *firstChild() const { return children.empty() ? nullptr : &children.front(); }
 
    SPObject *lastChild() { return children.empty() ? nullptr : &children.back(); }
    SPObject const *lastChild() const { return children.empty() ? nullptr : &children.back(); }
 
    SPObject *nthChild(unsigned index);
    SPObject const *nthChild(unsigned index) const;
 
    enum Action { ActionGeneral, ActionBBox, ActionUpdate, ActionShow };
 
    std::vector<SPObject*> childList(bool add_ref, Action action = ActionGeneral);
 
 
    std::vector<SPObject*> ancestorList(bool root_to_tip);
 
    SPObject *appendChildRepr(Inkscape::XML::Node *repr);
 
    char const *label() const;
 
    char const *defaultLabel() const;
 
    void setLabel(char const *label);
 
    char *title() const;
 
    bool setTitle(char const *title, bool verbatim = false);
 
    char *desc() const;
 
    bool setDesc(char const *desc, bool verbatim=false);
 
    Glib::ustring getExportFilename() const;
    void setExportFilename(Glib::ustring filename);
 
    Geom::Point getExportDpi() const;
    void setExportDpi(Geom::Point dpi);
 
    CollectionPolicy collectionPolicy() const { return _collection_policy; }
 
    void setCollectionPolicy(CollectionPolicy policy) {
        _collection_policy = policy;
    }
 
    void requestOrphanCollection();
 
    void collectOrphan() {
        if ( _total_hrefcount == 0 ) {
            deleteObject(false);
        }
    }
 
    void hrefObject(SPObject* owner = nullptr);
 
    void unhrefObject(SPObject* owner = nullptr);
 
    bool isReferenced() { return ( _total_hrefcount > 0 ); }
 
    void deleteObject(bool propagate, bool propagate_descendants);
 
    void deleteObject(bool propagate = true)
    {
        deleteObject(propagate, propagate);
    }
 
    void cropToObject(SPObject *except);
    void cropToObjects(std::vector<SPObject *> except_objects);
 
    void getObjectsExcept(std::vector<SPObject *> &objects, const std::vector<SPObject *> &except);
 
    void getLinkedRecursive(std::vector<SPObject *> &objects, LinkedObjectNature direction = LinkedObjectNature::ANY) const;
 
    sigc::connection connectDelete(sigc::slot<void (SPObject *)> slot) {
        return _delete_signal.connect(slot);
    }
 
    sigc::connection connectPositionChanged(sigc::slot<void (SPObject *)> slot) {
        return _position_changed_signal.connect(slot);
    }
 
    SPObject *successor() { return _successor; }
 
    void setSuccessor(SPObject *successor) {
        assert(successor != NULL);
        assert(_successor == NULL);
        assert(successor->_successor == NULL);
        sp_object_ref(successor, nullptr);
        _successor = successor;
    }
 
    void setTmpSuccessor(SPObject *tmpsuccessor);
 
    void unsetTmpSuccessor();
 
    void fixTmpSuccessors();
 
    /* modifications; all three sets of methods should probably ultimately be protected, as they
     * are not really part of its public interface.  However, other parts of the code to
     * occasionally use them at present. */
 
    /* the no-argument version of updateRepr() is intended to be a bit more public, however -- it
     * essentially just flushes any changes back to the backing store (the repr layer); maybe it
     * should be called something else and made public at that point. */
 
    Inkscape::XML::Node *updateRepr(unsigned int flags = SP_OBJECT_WRITE_EXT);
 
    Inkscape::XML::Node *updateRepr(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, unsigned int flags);
 
    void requestDisplayUpdate(unsigned int flags);
 
    void updateDisplay(SPCtx *ctx, unsigned int flags);
 
    void requestModified(unsigned int flags);
 
    void emitModified(unsigned int flags);
 
    sigc::connection connectModified(
      sigc::slot<void (SPObject *, unsigned int)> slot
    ) {
        return _modified_signal.connect(slot);
    }
 
    void _sendDeleteSignalRecursive();
 
    void _updateTotalHRefCount(int increment);
 
    void _requireSVGVersion(unsigned major, unsigned minor) { _requireSVGVersion(Inkscape::Version(major, minor)); }
 
    void _requireSVGVersion(Inkscape::Version version);
 
    sigc::signal<void (SPObject *)> _release_signal;
    sigc::signal<void (SPObject *)> _delete_signal;
    sigc::signal<void (SPObject *)> _position_changed_signal;
    sigc::signal<void (SPObject *, unsigned int)> _modified_signal;
    SPObject *_successor{nullptr};
    SPObject *_tmpsuccessor{nullptr};
    CollectionPolicy _collection_policy{SPObject::COLLECT_WITH_PARENT};
    char *_label{nullptr};
    mutable char *_default_label{nullptr};
 
    // WARNING:
    // Methods below should not be used outside of the SP tree,
    // as they operate directly on the XML representation.
    // In future, they will be made protected.
 
    void attach(SPObject *object, SPObject *prev);
 
    void reorder(SPObject* obj, SPObject *prev);
 
    void detach(SPObject *object);
 
    SPObject *get_child_by_repr(Inkscape::XML::Node *repr);
 
    void invoke_build(SPDocument *document, Inkscape::XML::Node *repr, unsigned int cloned);
 
    int getIntAttribute(char const *key, int def);
 
    unsigned getPosition();
 
    char const * getAttribute(char const *name) const;
 
    void appendChild(Inkscape::XML::Node *child);
 
    void addChild(Inkscape::XML::Node *child,Inkscape::XML::Node *prev=nullptr);
 
    void setKeyValue(SPAttr key, char const *value);
 
 
    void setAttribute(Inkscape::Util::const_char_ptr key,
                      Inkscape::Util::const_char_ptr value);
 
    void setAttributeDouble(Inkscape::Util::const_char_ptr key, double value);
 
    void setAttributeOrRemoveIfEmpty(Inkscape::Util::const_char_ptr key,
                                     Inkscape::Util::const_char_ptr value) {
        this->setAttribute(key.data(),
                          (value.data() == nullptr || value.data()[0]=='\0') ? nullptr : value.data());
    }
 
    void readAttr(char const *key);
    void readAttr(SPAttr keyid);
 
    char const *getTagName() const;
 
    void removeAttribute(char const *key);
 
    void setCSS(SPCSSAttr *css, char const *attr);
 
    void changeCSS(SPCSSAttr *css, char const *attr);
 
    bool storeAsDouble( char const *key, double *val ) const;
 
private:
    // Private member functions used in the definitions of setTitle(),
    // setDesc(), title() and desc().
 
    bool setTitleOrDesc(char const *value, char const *svg_tagname, bool verbatim);
 
    char * getTitleOrDesc(char const *svg_tagname) const;
 
    SPObject * findFirstChild(char const *tagname) const;
 
    Glib::ustring textualContent() const;
 
    /* Real handlers of repr signals */
 
private:
    // XML::NodeObserver functions
    void notifyAttributeChanged(Inkscape::XML::Node &node, GQuark key, Inkscape::Util::ptr_shared oldval,
                                Inkscape::Util::ptr_shared newval) final;
 
    void notifyContentChanged(Inkscape::XML::Node &node, Inkscape::Util::ptr_shared oldcontent,
                              Inkscape::Util::ptr_shared newcontent) final;
 
    void notifyChildAdded(Inkscape::XML::Node &node, Inkscape::XML::Node &child,
                          Inkscape::XML::Node *prev) final;
 
    void notifyChildRemoved(Inkscape::XML::Node &node, Inkscape::XML::Node &child,
                            Inkscape::XML::Node *prev) final;
 
    void notifyChildOrderChanged(Inkscape::XML::Node &node, Inkscape::XML::Node &child, Inkscape::XML::Node *old_prev,
                                 Inkscape::XML::Node *new_prev) final;
 
    void notifyElementNameChanged(Inkscape::XML::Node &node, GQuark old_name, GQuark new_name) final;
 
    friend class SPObjectImpl;
 
protected:
    virtual void build(SPDocument *doc, Inkscape::XML::Node *repr);
    virtual void release();
 
    virtual void child_added(Inkscape::XML::Node *child, Inkscape::XML::Node *ref);
    virtual void remove_child(Inkscape::XML::Node *child);
 
    virtual void order_changed(Inkscape::XML::Node *child, Inkscape::XML::Node *old_repr,
                               Inkscape::XML::Node *new_repr);
    virtual void tag_name_changed(gchar const *oldname, gchar const *newname);
 
    virtual void set(SPAttr key, const char *value);
 
    virtual void update(SPCtx *ctx, unsigned int flags);
    virtual void modified(unsigned int flags);
 
    virtual Inkscape::XML::Node *write(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, unsigned int flags);
 
    typedef boost::intrusive::list_member_hook<> ListHook;
    ListHook _child_hook;
 
public:
    using ChildrenList = boost::intrusive::list<
        SPObject,
        boost::intrusive::member_hook<
            SPObject,
            ListHook,
            &SPObject::_child_hook
        >>;
    ChildrenList children;
    virtual void read_content();
 
    void recursivePrintTree(unsigned level = 0); // For debugging
    void objectTrace(std::string const &, bool in = true, unsigned flags = 0);
 
    std::string generate_unique_id(char const *default_id = nullptr) const;
};
 
std::ostream &operator<<(std::ostream &out, const SPObject &o);
 
int sp_object_compare_position(SPObject const *first, SPObject const *second);
bool sp_object_compare_position_bool(SPObject const *first, SPObject const *second);
 
#endif // SP_OBJECT_H_SEEN
 
/*
  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 :