selection.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Authors:
 *   Lauris Kaplinski <lauris@kaplinski.com>
 *   MenTaLguY <mental@rydia.net>
 *   bulia byak <buliabyak@users.sf.net>
 *   Adrian Boguszewski
 *
 * Copyright (C) 2016 Adrian Boguszewski
 * Copyright (C) 2004-2005 MenTaLguY
 * Copyright (C) 1999-2002 Lauris Kaplinski
 * Copyright (C) 2001-2002 Ximian, Inc.
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#ifndef SEEN_INKSCAPE_SELECTION_H
#define SEEN_INKSCAPE_SELECTION_H
 
#include <cstddef>
#include <list>
#include <unordered_map>
#include <utility>
#include <vector>
#include <sigc++/signal.h>
#include <sigc++/slot.h>
 
#include <sigc++/scoped_connection.h>
#include "object/object-set.h"
 
namespace Inkscape {
 
namespace XML {
class Node;
} // namespace XML
 
struct PathNodeState
{
    std::string path_id; // ID of the path containing the node
    int subpath_index;   // Index of the subpath
    int node_index;      // Index of the node within the subpath
 
    PathNodeState(std::string id, int sp, int n)
        : path_id(std::move(id))
        , subpath_index(sp)
        , node_index(n)
    {}
};
 
struct SelectionState
{
    std::vector<std::string> selected_ids;     // IDs of selected objects
    std::vector<PathNodeState> selected_nodes; // Selected path nodes (when node tool is active)
};
 
class Selection : public ObjectSet
{
public:
    Selection(SPDesktop *desktop);
    Selection(SPDocument *document);
    ~Selection() override;
 
    SPObject *activeContext();
 
    using ObjectSet::add;
 
    void add(XML::Node *repr) {
        add(_objectForXMLNode(repr));
    }
 
     using ObjectSet::set;
 
    void set(XML::Node *repr) {
        set(_objectForXMLNode(repr));
    }
 
    using ObjectSet::remove;
 
    void remove(XML::Node *repr) {
        remove(_objectForXMLNode(repr));
    }
 
    using ObjectSet::includes;
 
    bool includes(XML::Node *repr, bool anyAncestor = false) {
        return includes(_objectForXMLNode(repr), anyAncestor);
    }
 
    using ObjectSet::includesAncestor;
    
    SPObject * includesAncestor(XML::Node *repr) {
        return includesAncestor(_objectForXMLNode(repr));
    }
 
    size_t numberOfLayers();
 
    size_t numberOfParents();
 
    std::vector<Inkscape::SnapCandidatePoint> getSnapPoints(SnapPreferences const *snapprefs) const;
 
    // Fixme: Hack should not exist, but used by live_effects.
    void emitModified() { _emitModified(_flags); };
 
    sigc::connection connectChanged(sigc::slot<void (Selection *)> slot) {
        return _changed_signal.connect(std::move(slot));
    }
 
    sigc::connection connectChangedFirst(sigc::slot<void (Selection *)> slot) {
        return _changed_signal.connect_first(std::move(slot));
    }
 
    void setAnchor(double x, double y, bool set = true);
    // Allow the selection to specify a facus anchor (helps with transforming against this point)
    bool has_anchor = false;
    Geom::Point anchor;
 
    void scaleAnchored(double amount, bool fixed = true);
 
    void rotateAnchored(double angle_degrees, double zoom = 1.0);
 
    sigc::connection connectModified(sigc::slot<void (Selection *, unsigned)> slot) {
        return _modified_signal.connect(std::move(slot));
    }
 
    sigc::connection connectModifiedFirst(sigc::slot<void (Selection *, unsigned)> slot) {
        return _modified_signal.connect_first(std::move(slot));
    }
 
    SelectionState getState();
 
    void setState(SelectionState const &state);
 
    void setChangeLayer(bool option) { _change_layer = option; }
    void setChangePage(bool option) { _change_page = option; }
 
protected:
    void _connectSignals(SPObject* object) override;
    void _releaseSignals(SPObject* object) override;
 
private:
    static int _emit_modified(Selection *selection);
    void _schedule_modified(SPObject *obj, unsigned int flags);
 
    void _emitModified(unsigned int flags);
    void _emitChanged(bool persist_selection_context = false) override;
    SPObject *_objectForXMLNode(XML::Node *repr) const;
    void _releaseContext(SPObject *obj);
 
    SPObject *_selection_context = nullptr;
    unsigned _flags = 0;
    unsigned _idle = 0;
    bool _change_layer = true;
    bool _change_page = true;
    std::unordered_map<SPObject *, sigc::scoped_connection> _modified_connections;
    sigc::scoped_connection _context_release_connection;
 
    sigc::signal<void (Selection *)> _changed_signal;
    sigc::signal<void (Selection *, unsigned)> _modified_signal;
 
    Geom::Point _previous_rotate_anchor;
};
 
} // namespace Inkscape
 
#endif // SEEN_INKSCAPE_SELECTION_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 :