object-set.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Multiindex container for selection
 *
 * Authors:
 *   Adrian Boguszewski
 *   Marc Jeanmougin
 *
 * Copyright (C) 2016 Adrian Boguszewski
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#ifndef INKSCAPE_PROTOTYPE_OBJECTSET_H
#define INKSCAPE_PROTOTYPE_OBJECTSET_H
 
#include <string>
#include <unordered_map>
 
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/identity.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/random_access_index.hpp>
#include <boost/range/adaptor/filtered.hpp>
#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/sub_range.hpp>
#include <boost/range/any_range.hpp>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
 
#include <sigc++/connection.h>
 
#include "sp-object.h"
#include "sp-item.h"
#include "sp-item-group.h"
#include "livarot/LivarotDefs.h"
 
enum class SiblingState {
    SIBLING_NONE,       // no relation to item
    SIBLING_CLONE_ORIGINAL, // moving both a clone and its original or any ancestor
    SIBLING_OFFSET_SOURCE,  // moving both an offset and its source
    SIBLING_TEXT_PATH,      // moving both a text-on-path and its path
    SIBLING_TEXT_FLOW_FRAME,    // moving both a flowtext and its frame
    SIBLING_TEXT_SHAPE_INSIDE,  // moving object containing sub object
};
 
class SPDocument;
class SPDesktop;
 
class SPBox3D;
class Persp3D;
 
namespace Inkscape {
 
namespace XML {
class Node;
}
 
struct hashed{};
struct random_access{};
 
struct is_item {
    bool operator()(SPObject* obj) {
        return is<SPItem>(obj);
    }
};
 
struct is_group {
    bool operator()(SPObject* obj) {
        return is<SPGroup>(obj);
    }
};
 
struct object_to_item {
    typedef SPItem* result_type;
    SPItem* operator()(SPObject* obj) const {
        return cast<SPItem>(obj);
    }
};
 
struct object_to_node {
    typedef XML::Node* result_type;
    XML::Node* operator()(SPObject* obj) const {
        return obj->getRepr();
    }
};
 
struct object_to_group {
    typedef SPGroup* result_type;
    SPGroup* operator()(SPObject* obj) const {
        return cast<SPGroup>(obj);
    }
};
 
typedef boost::multi_index_container<
        SPObject*,
        boost::multi_index::indexed_by<
                boost::multi_index::sequenced<>,
                boost::multi_index::random_access<
                        boost::multi_index::tag<random_access>>,
                boost::multi_index::hashed_unique<
                        boost::multi_index::tag<hashed>,
                        boost::multi_index::identity<SPObject*>>
        >> MultiIndexContainer;
 
typedef boost::any_range<
        SPObject*,
        boost::random_access_traversal_tag,
        SPObject* const&,
        std::ptrdiff_t> SPObjectRange;
 
class ObjectSet {
public:
    enum CompareSize {HORIZONTAL, VERTICAL, AREA};
    typedef decltype(MultiIndexContainer().get<random_access>() | boost::adaptors::filtered(is_item()) | boost::adaptors::transformed(object_to_item())) SPItemRange;
    typedef decltype(MultiIndexContainer().get<random_access>() | boost::adaptors::filtered(is_group()) | boost::adaptors::transformed(object_to_group())) SPGroupRange;
    typedef decltype(MultiIndexContainer().get<random_access>() | boost::adaptors::filtered(is_item()) | boost::adaptors::transformed(object_to_node())) XMLNodeRange;
 
    ObjectSet(SPDesktop* desktop);
    ObjectSet(SPDocument* doc): _desktop(nullptr), _document(doc) {};
    ObjectSet(): _desktop(nullptr), _document(nullptr) {}; // Used in spray-tool.h.
    virtual ~ObjectSet();
 
    ObjectSet(ObjectSet const &) = delete;
    ObjectSet &operator=(ObjectSet const &) = delete;
    
    void setDocument(SPDocument* doc){
        _document = doc;
    }
    
 
    bool add(SPObject *object, bool nosignal = false);
 
    void add(XML::Node *repr);
 
    template <typename InputIterator>
    void add(InputIterator from, InputIterator to) {
        for(auto it = from; it != to; ++it) {
            _add(*it);
        }
        _emitChanged();
    }
 
    bool remove(SPObject* object);
 
    bool includes(SPObject *object, bool anyAncestor = false);
    bool includes(Inkscape::XML::Node *node, bool anyAncestor = false);
 
    SPObject * includesAncestor(SPObject *object);
 
    void set(SPObject *object, bool persist_selection_context = false);
    void set(XML::Node *repr);
    void clear();
 
    int size();
 
    bool isEmpty();
 
    void toggle(SPObject *obj);
 
    SPObject *single();
 
    SPItem *singleItem();
 
    SPItem *firstItem() const;
 
    SPItem *lastItem() const;
 
    SPItem *smallestItem(CompareSize compare);
 
    SPItem *largestItem(CompareSize compare);
 
    SPObjectRange objects();
 
    SPItemRange items() {
        return SPItemRange(_container.get<random_access>()
           | boost::adaptors::filtered(is_item())
           | boost::adaptors::transformed(object_to_item()));
    };
 
    std::vector<SPItem*> items_vector() {
        auto i = items();
        return {i.begin(), i.end()};
    }
 
    SPGroupRange groups() {
        return SPGroupRange (_container.get<random_access>()
            | boost::adaptors::filtered(is_group())
            | boost::adaptors::transformed(object_to_group()));
    }
 
    XMLNodeRange xmlNodes() {
        return XMLNodeRange(_container.get<random_access>()
                            | boost::adaptors::filtered(is_item())
                            | boost::adaptors::transformed(object_to_node()));
    }
 
    XML::Node *singleRepr();
 
    XML::Node *topRepr() const;
 
    template <class T>
    typename boost::enable_if<boost::is_base_of<SPObject, T>, void>::type
    setList(const std::vector<T*> &objs) {
        _clear();
        addList(objs);
    }
 
    void setReprList(std::vector<XML::Node*> const &list);
 
    void enforceIds();
 
    template <class T>
    typename boost::enable_if<boost::is_base_of<SPObject, T>, void>::type
    addList(const std::vector<T*> &objs) {
        for (auto obj: objs) {
            if (!includes(obj)) {
                add(obj, true);
            }
        }
        _emitChanged();
    }
 
    Geom::OptRect bounds(SPItem::BBoxType type) const;
    Geom::OptRect visualBounds() const;
    Geom::OptRect geometricBounds() const;
    Geom::OptRect strokedBounds() const;
 
    Geom::OptRect preferredBounds() const;
 
    /* Returns the bounding rectangle of the selectionin document coordinates.*/
    Geom::OptRect documentBounds(SPItem::BBoxType type) const;
 
    Geom::OptRect documentPreferredBounds() const;
 
    std::optional<Geom::Point> center() const;
 
    std::list<Persp3D *> const perspList();
 
    std::list<SPBox3D *> const box3DList(Persp3D *persp = nullptr);
 
    SPDesktop *desktop() { return _desktop; }
 
    SPDocument *document() { return _document; }
 
    //item groups operations
    //in selection-chemistry.cpp
    void deleteItems(bool skip_undo = false);
    void duplicate(bool suppressDone = false, bool duplicateLayer = false);
    void clone(bool skip_undo = false);
 
    bool unlink(const bool skip_undo = false, const bool silent = false);
    bool unlinkRecursive(const bool skip_undo = false, const bool force = false, const bool silent = false);
    void removeLPESRecursive(bool keep_paths);
    void relink();
    void cloneOriginal();
    void cloneOriginalPathLPE(bool allow_transforms = false, bool sync = false, bool skip_undo = false);
    Inkscape::XML::Node* group(bool is_anchor = false);
    void popFromGroup();
    void ungroup(bool skip_undo = false);
    void ungroup_all(bool skip_undo = false);
    
    //z-order management
    //in selection-chemistry.cpp
    void stackUp(bool skip_undo = false);
    void raise(bool skip_undo = false);
    void raiseToTop(bool skip_undo = false);
    void stackDown(bool skip_undo = false);
    void lower(bool skip_undo = false);
    void lowerToBottom(bool skip_undo = false);
    void toNextLayer(bool skip_undo = false);
    void toPrevLayer(bool skip_undo = false);
    void toLayer(SPObject *layer);
    void toLayer(SPObject *layer, Inkscape::XML::Node *after);
 
    //clipboard management
    //in selection-chemistry.cpp
    void copy();
    void cut();
    void pasteStyle();
    void pasteSize(bool apply_x, bool apply_y);
    void pasteSizeSeparately(bool apply_x, bool apply_y);
    void pastePathEffect();
    
    //path operations
    //in path-chemistry.cpp
    void combine(bool skip_undo = false, bool silent = false);
    void breakApart(bool skip_undo = false, bool overlapping = true, bool silent = false);
    void toCurves(bool skip_undo = false, bool clonesjustunlink = false);
    void toLPEItems();
    void pathReverse();
 
    // path operations
    // in path/path-object-set.cpp
    bool strokesToPaths(bool legacy = false, bool skip_undo = false);
    bool simplifyPaths(bool skip_undo = false);
 
    // Boolean operations
    void pathUnion    (bool skip_undo = false, bool silent = false);
    void pathIntersect(bool skip_undo = false, bool silent = false);
    void pathDiff     (bool skip_undo = false, bool silent = false);
    void pathSymDiff  (bool skip_undo = false, bool silent = false);
    void pathCut      (bool skip_undo = false, bool silent = false);
    void pathSlice    (bool skip_undo = false, bool silent = false);
 
    // Other path operations
    // in selection-chemistry.cpp
    void toMarker(bool apply = true);
    void toGuides();
    void toSymbol();
    void unSymbol();
    void tile(bool apply = true); //"Object to Pattern"
    void untile();
    void createBitmapCopy();
    void setMask(bool apply_clip_path, bool apply_to_layer, bool remove_original);
    void editMask(bool clip);
    void unsetMask(const bool apply_clip_path, const bool delete_helper_group, bool remove_original);
    void setClipGroup();
    void chameleonFill();
    
    // moves
    // in selection-chemistry.cpp
    void removeLPE();
    void removeFilter();
    void reapplyAffine();
    void clearLastAffine();
    void applyAffine(Geom::Affine const &affine, bool set_i2d=true,bool compensate=true, bool adjust_transf_center=true);
    void removePathTransforms();
    void removeTransform();
    void setScaleAbsolute(double, double, double, double);
    void scaleRelative(const Geom::Point&, const Geom::Scale&);
    void rotateRelative(const Geom::Point&, double);
    void skewRelative(const Geom::Point&, double, double);
    void moveRelative(const Geom::Point &move, bool compensate = true);
    void moveRelative(double dx, double dy);
    void move(double dx, double dy);
    void moveScreen(double dx, double dy);
    void move(double dx, double dy, bool rotated);
    void move(double dx, double dy, bool rotated, bool screen);
    void moveScreen(double dx, double dy, bool rotated);
    
    // various
    bool fitCanvas(bool with_margins, bool skip_undo = false);
    void swapFillStroke();
    void fillBetweenMany();
 
    SiblingState getSiblingState(SPItem *item);
    void insertSiblingState(SPObject *object, SiblingState state);
    void clearSiblingStates();
 
protected:
    virtual void _connectSignals(SPObject* object) {};
    virtual void _releaseSignals(SPObject* object) {};
    virtual void _emitChanged(bool persist_selection_context = false);
    void _add(SPObject* object);
    void _clear();
    void _remove(SPObject* object);
    bool _anyAncestorIsInSet(SPObject *object);
    void _removeDescendantsFromSet(SPObject *object);
    void _removeAncestorsFromSet(SPObject *object);
    SPItem *_sizeistItem(bool sml, CompareSize compare);
    SPObject *_getMutualAncestor(SPObject *object);
    virtual void _add3DBoxesRecursively(SPObject *obj);
    virtual void _remove3DBoxesRecursively(SPObject *obj);
 
    MultiIndexContainer _container;
    SPDesktop * _desktop = nullptr;
    SPDocument *_document = nullptr;
    std::list<SPBox3D *> _3dboxes;
    std::unordered_map<SPObject*, sigc::connection> _releaseConnections;
 
private:
    void _pathBoolOp(BooleanOp bop, char const *icon_name, char const *description, bool skip_undo, bool silent);
    void _pathBoolOp(BooleanOp bop);
 
    void _disconnect(SPObject* object);
    std::map<SPObject *, SiblingState> _sibling_state;
 
    Geom::Affine _last_affine;
};
 
using SPItemRange = ObjectSet::SPItemRange;
using SPGroupRange = ObjectSet::SPGroupRange;
using XMLNodeRange = ObjectSet::XMLNodeRange;
 
} // namespace Inkscape
 
#endif // INKSCAPE_PROTOTYPE_OBJECTSET_H
 
/*
  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 :