snap.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Per-desktop object that handles snapping queries.
 *
 * Authors:
 *   Lauris Kaplinski <lauris@kaplinski.com>
 *   Frank Felfe <innerspace@iname.com>
 *   Carl Hetherington <inkscape@carlh.net>
 *   Diederik van Lierop <mail@diedenrezi.nl>
 *
 * Copyright (C) 2006-2007 Johan Engelen <johan@shouraizou.nl>
 * Copyright (C) 2000-2002 Lauris Kaplinski
 * Copyright (C) 2000-2012 Authors
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#ifndef SEEN_SNAP_H
#define SEEN_SNAP_H
 
#include <memory>
#include <vector>
 
#include "guide-snapper.h"
#include "object-snapper.h"
#include "alignment-snapper.h"
#include "snap-preferences.h"
#include "distribution-snapper.h"
 
 
// Guides
enum SPGuideDragType { // used both here and in desktop-events.cpp
    SP_DRAG_TRANSLATE,
    SP_DRAG_ROTATE,
    SP_DRAG_MOVE_ORIGIN,
    SP_DRAG_NONE
};
 
class SPDocument;
class SPGuide;
class SPPage;
class SPNamedView;
 
namespace Inkscape {
    class PureTransform;
}
 
 
class SnapManager
{
public:
    enum Transformation {
        TRANSLATE,
        SCALE,
        STRETCH,
        SKEW,
        ROTATE
    };
    SnapManager(SPNamedView const *v, Inkscape::SnapPreferences& preferences);
    ~SnapManager();
 
    typedef std::list<const Inkscape::Snapper*> SnapperList;
 
    bool someSnapperMightSnap(bool immediately = true) const;
 
    bool gridSnapperMightSnap() const;
 
    void setup(SPDesktop const *desktop,
            bool snapindicator = true,
            SPObject const *item_to_ignore = nullptr,
            std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes = nullptr);
 
    void setup(SPDesktop const *desktop,
               bool snapindicator,
               std::vector<SPObject const *> &objects_to_ignore,
               std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes = nullptr);
 
    void setupIgnoreSelection(SPDesktop const *desktop,
                              bool snapindicator = true,
                              std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes = nullptr);
 
    void unSetup() {_rotation_center_source_items.clear();
                    _objects_to_ignore.clear();
                    _desktop = nullptr;
                    _unselected_nodes = nullptr;}
 
    // If we're dragging a rotation center, then setRotationCenterSource() stores the parent item
    // of this rotation center; this reference is used to make sure that we do not snap a rotation
    // center to itself
    // NOTE: Must be called after calling setup(), not before!
    void setRotationCenterSource(const std::vector<SPItem*> &items) {_rotation_center_source_items = items;}
    const std::vector<SPItem*> &getRotationCenterSource() {return _rotation_center_source_items;}
 
    // freeSnapReturnByRef() is preferred over freeSnap(), because it only returns a
    // point if snapping has occurred (by overwriting p); otherwise p is untouched
 
    void freeSnapReturnByRef(Geom::Point &p,
                             Inkscape::SnapSourceType const source_type,
                             Geom::OptRect const &bbox_to_snap = Geom::OptRect()) const;
 
    Inkscape::SnappedPoint freeSnap(Inkscape::SnapCandidatePoint const &p,
                                    Geom::OptRect const &bbox_to_snap = Geom::OptRect(),
                                    bool to_path_only = false) const;
 
    void preSnap(Inkscape::SnapCandidatePoint const &p, bool to_path_only = false);
 
    Geom::Point multipleOfGridPitch(Geom::Point const &t, Geom::Point const &origin);
 
    // constrainedSnapReturnByRef() is preferred over constrainedSnap(), because it only returns a
    // point, by overwriting p, if snapping has occurred; otherwise p is untouched
 
    void constrainedSnapReturnByRef(Geom::Point &p,
                                    Inkscape::SnapSourceType const source_type,
                                    Inkscape::Snapper::SnapConstraint const &constraint,
                                    Geom::OptRect const &bbox_to_snap = Geom::OptRect()) const;
 
    Inkscape::SnappedPoint constrainedSnap(Inkscape::SnapCandidatePoint const &p,
                                           Inkscape::Snapper::SnapConstraint const &constraint,
                                           Geom::OptRect const &bbox_to_snap = Geom::OptRect()) const;
 
    Inkscape::SnappedPoint multipleConstrainedSnaps(Inkscape::SnapCandidatePoint const &p,
                                                    std::vector<Inkscape::Snapper::SnapConstraint> const &constraints,
                                                    bool dont_snap = false,
                                                    Geom::OptRect const &bbox_to_snap = Geom::OptRect()) const;
 
    Inkscape::SnappedPoint constrainedAngularSnap(Inkscape::SnapCandidatePoint const &p,
                                                    std::optional<Geom::Point> const &p_ref,
                                                    Geom::Point const &o,
                                                    unsigned const snaps) const;
 
    void guideFreeSnap(Geom::Point &p, Geom::Point &origin_or_vector, bool origin, bool freeze_angle) const;
 
    void guideConstrainedSnap(Geom::Point &p, SPGuide const &guideline) const;
 
    Inkscape::GuideSnapper guide;      
    Inkscape::ObjectSnapper object;    
    Inkscape::AlignmentSnapper alignment; 
    Inkscape::DistributionSnapper distribution;
    Inkscape::SnapPreferences& snapprefs;
 
    SnapperList getSnappers() const;
 
    SnapperList getGridSnappers() const;
 
    SPDesktop const *getDesktop() const {return _desktop;}
    SPNamedView const *getNamedView() const {return _named_view;}
    SPDocument *getDocument() const;
    SPGuide const *getGuideToIgnore() const;
    SPPage const *getPageToIgnore() const;
 
    bool getSnapIndicator() const {return _snapindicator;}
 
    Inkscape::SnappedPoint findBestSnap(Inkscape::SnapCandidatePoint const &p, IntermSnapResults const &isr, bool constrained, bool allowOffScreen = false, bool to_paths_only = false) const;
 
    void displaySnapsource(Inkscape::SnapCandidatePoint const &p) const;
 
    void snapTransformed(std::vector<Inkscape::SnapCandidatePoint> const &points,
                                            Geom::Point const &pointer,
                                            Inkscape::PureTransform &transform);
 
protected:
    SPNamedView const *_named_view;
 
private:
    std::vector<SPObject const *> _objects_to_ignore; 
    std::vector<SPItem*> _rotation_center_source_items; // to avoid snapping a rotation center to itself
    SPDesktop const *_desktop;
    bool _snapindicator; 
    std::vector<Inkscape::SnapCandidatePoint> *_unselected_nodes; 
 
    void _findCandidates(SPObject* parent,
                       std::vector<SPObject const *> const *it,
                       Geom::Rect const &bbox_to_snap,
                       bool const _clip_or_mask,
                       Geom::Affine const additional_affine);
    bool _findCandidates_already_called;
 
    std::unique_ptr<std::vector<Inkscape::SnapCandidateItem>> _obj_snapper_candidates;
    std::unique_ptr<std::vector<Inkscape::SnapCandidateItem>> _align_snapper_candidates;
 
    friend class Inkscape::ObjectSnapper;
    friend class Inkscape::AlignmentSnapper;
    friend class Inkscape::DistributionSnapper;
};
 
#endif // !SEEN_SNAP_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 :