Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 412 insertions, 0 deletions

diff --git a/src/actions/actions-canvas-snapping.cpp b/src/actions/actions-canvas-snapping.cpp
new file mode 100644
index 0000000..460bc95
--- /dev/null
+++ b/src/actions/actions-canvas-snapping.cpp
@@ -0,0 +1,412 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Gio::Actions for toggling snapping preferences. Not tied to a particular document.
+ *
+ * Copyright (C) 2019 Tavmjong Bah
+ *
+ * The contents of this file may be used under the GNU General Public License Version 2 or later.
+ *
+ */
+
+#include <iostream>
+#include <unordered_map>
+#include <vector>
+
+#include <giomm.h>  // Not <gtkmm.h>! To eventually allow a headless version!
+#include <glibmm/i18n.h>
+
+#include "actions-canvas-snapping.h"
+#include "actions/actions-extra-data.h"
+#include "inkscape-application.h"
+#include "inkscape.h"
+#include "inkscape-window.h"
+#include "desktop.h"
+#include "snap-preferences.h"
+
+using namespace Inkscape;
+
+void set_actions_canvas_snapping(Gio::ActionMap& map);
+
+// There are two snapping lists that must be connected:
+// 1. The Inkscape::SNAPTARGET value:  e.g. Inkscape::SNAPTARGET_BBOX_CATEGORY.
+// 2. The Gio::Action name:            e.g. "snap-bbox"
+
+struct SnapInfo {
+    Glib::ustring action_name; // action name without "doc." prefix
+    SnapTargetType type;       // corresponding snapping type
+    bool set;                  // this is default for when "simple snapping" is ON and also initial value when preferences are deleted
+};
+
+typedef std::vector<SnapInfo> SnapVector;
+typedef std::unordered_map<SnapTargetType, Glib::ustring> SnapMap;
+
+SnapVector snap_bbox = {
+    { "snap-bbox",               SNAPTARGET_BBOX_CATEGORY,      true },
+    { "snap-bbox-edge",          SNAPTARGET_BBOX_EDGE,          true },
+    { "snap-bbox-corner",        SNAPTARGET_BBOX_CORNER,        true },
+    { "snap-bbox-edge-midpoint", SNAPTARGET_BBOX_EDGE_MIDPOINT, false },
+    { "snap-bbox-center",        SNAPTARGET_BBOX_MIDPOINT,      false },
+};
+
+SnapVector snap_node = {
+    { "snap-node-category",      SNAPTARGET_NODE_CATEGORY,      true },
+    { "snap-path",               SNAPTARGET_PATH,               true },
+    { "snap-path-intersection",  SNAPTARGET_PATH_INTERSECTION,  false }, // Note: OFF by default, as it is extremely slow in large documents!
+    { "snap-node-cusp",          SNAPTARGET_NODE_CUSP,          true },
+    { "snap-node-smooth",        SNAPTARGET_NODE_SMOOTH,        true },
+    { "snap-line-midpoint",      SNAPTARGET_LINE_MIDPOINT,      true },
+    { "snap-line-tangential",    SNAPTARGET_PATH_TANGENTIAL,    false },
+    { "snap-line-perpendicular", SNAPTARGET_PATH_PERPENDICULAR, false },
+};
+
+SnapVector snap_alignment = {
+    { "snap-alignment",          SNAPTARGET_ALIGNMENT_CATEGORY,    true },
+    { "snap-alignment-self",     SNAPTARGET_ALIGNMENT_HANDLE,      false },
+    // separate category:
+    { "snap-distribution",       SNAPTARGET_DISTRIBUTION_CATEGORY, true },
+};
+
+SnapVector snap_all_the_rest = {
+    { "snap-others",             SNAPTARGET_OTHERS_CATEGORY,    true },
+    { "snap-object-midpoint",    SNAPTARGET_OBJECT_MIDPOINT,    false },
+    { "snap-rotation-center",    SNAPTARGET_ROTATION_CENTER,    false },
+    { "snap-text-baseline",      SNAPTARGET_TEXT_BASELINE,      true },
+    { "snap-path-mask",          SNAPTARGET_PATH_MASK,          true },
+    { "snap-path-clip",          SNAPTARGET_PATH_CLIP,          true },
+
+    { "snap-page-border",        SNAPTARGET_PAGE_BORDER,        true },
+    { "snap-grid",               SNAPTARGET_GRID,               true },
+    { "snap-guide",              SNAPTARGET_GUIDE,              true },
+};
+
+const struct {const char* action_name; SimpleSnap option; bool set;} simple_snap_options[] = {
+    { "simple-snap-bbox",      SimpleSnap::BBox,      true },
+    { "simple-snap-nodes",     SimpleSnap::Nodes,     true },
+    { "simple-snap-alignment", SimpleSnap::Alignment, false }
+};
+
+const SnapMap& get_snap_map() {
+    static SnapMap map;
+    if (map.empty()) {
+        for (auto&& snap : snap_bbox)           { map[snap.type] = snap.action_name; }
+        for (auto&& snap : snap_node)           { map[snap.type] = snap.action_name; }
+        for (auto&& snap : snap_alignment)      { map[snap.type] = snap.action_name; }
+        for (auto&& snap : snap_all_the_rest)   { map[snap.type] = snap.action_name; }
+    }
+    return map;
+}
+
+const SnapVector& get_snap_vect() {
+    static SnapVector vect;
+    if (vect.empty()) {
+        for (auto v : {&snap_bbox, &snap_node, &snap_alignment, &snap_all_the_rest}) {
+            vect.insert(vect.end(), v->begin(), v->end());
+        }
+    }
+    return vect;
+}
+
+const Glib::ustring snap_pref_path = "/options/snapping/";
+const Glib::ustring global_toggle = "snap-global-toggle";
+
+// global and single location of snapping preferences
+SnapPreferences& get_snapping_preferences() {
+    static SnapPreferences preferences;
+    static bool initialized = false;
+
+    if (!initialized) {
+        // after starting up restore all snapping preferences:
+        auto prefs = Preferences::get();
+        for (auto&& info : get_snap_vect()) {
+            bool enabled = prefs->getBool(snap_pref_path + info.action_name, info.set);
+            preferences.setTargetSnappable(info.type, enabled);
+        }
+        for (auto&& info : simple_snap_options) {
+            bool enabled = prefs->getBool(snap_pref_path + info.action_name, info.set);
+            preferences.set_simple_snap(info.option, enabled);
+        }
+
+        auto simple = prefs->getEntry("/toolbox/simplesnap");
+        if (!simple.isValid()) {
+            // first time up after creating preferences; apply "simple" snapping defaults
+            prefs->setBool(simple.getPath(), true);
+            transition_to_simple_snapping();
+        }
+
+        auto enabled = prefs->getEntry(snap_pref_path + global_toggle);
+        preferences.setSnapEnabledGlobally(enabled.getBool());
+
+        initialized = true;
+    }
+
+    return preferences;
+}
+
+void store_snapping_action(const Glib::ustring& action_name, bool enabled) {
+    Preferences::get()->setBool(snap_pref_path + action_name, enabled);
+}
+
+// Turn requested snapping type on or off:
+// * type - snap target
+// * enabled - true to turn it on, false to turn it off
+//
+void set_canvas_snapping(SnapTargetType type, bool enabled) {
+    get_snapping_preferences().setTargetSnappable(type, enabled);
+
+    auto it = get_snap_map().find(type);
+    if (it == get_snap_map().end()) {
+        g_warning("No action for snap target type %d", int(type));
+    }
+    else {
+        auto&& action_name = it->second;
+        store_snapping_action(action_name, enabled);
+    }
+}
+
+void update_actions(Gio::ActionMap& map) {
+    // Some actions depend on others... we need to update everything!
+    set_actions_canvas_snapping(map);
+}
+
+static void canvas_snapping_toggle(Gio::ActionMap& map, SnapTargetType type) {
+    bool enabled = get_snapping_preferences().isSnapButtonEnabled(type);
+    set_canvas_snapping(type, !enabled);
+    update_actions(map);
+}
+
+void set_simple_snap(SimpleSnap option, bool value) {
+    const SnapVector* vect = nullptr;
+    switch (option) {
+    case SimpleSnap::BBox:
+        vect = &snap_bbox;
+        break;
+    case SimpleSnap::Nodes:
+        vect = &snap_node;
+        break;
+    case SimpleSnap::Alignment:
+        vect = &snap_alignment;
+        break;
+    case SimpleSnap::Rest:
+        vect = &snap_all_the_rest;
+        break;
+    default:
+        std::cerr << "missing case statement in " << __func__ << std::endl;
+        break;
+    }
+
+    if (vect) {
+        for (auto&& info : *vect) {
+            bool enable = value && info.set;
+            set_canvas_snapping(info.type, enable);
+        }
+
+        Glib::ustring action_name;
+        for (auto&& info : simple_snap_options) {
+            if (info.option == option) {
+                action_name = info.action_name;
+                break;
+            }
+        }
+        // simple snap option 'Rest' does not have an action; only save other ones
+        if (!action_name.empty()) {
+            get_snapping_preferences().set_simple_snap(option, value);
+            Preferences::get()->setBool(snap_pref_path + action_name, value);
+        }
+    }
+}
+
+void toggle_simple_snap_option(Gio::ActionMap& map, SimpleSnap option) {
+    // toggle desired option
+    bool enabled = !get_snapping_preferences().get_simple_snap(option);
+    set_simple_snap(option, enabled);
+
+    // reset others not visible / not exposed to their "simple" defaults
+    for (auto&& info : snap_all_the_rest) {
+        set_canvas_snapping(info.type, info.set);
+    }
+
+    update_actions(map);
+}
+
+void apply_simple_snap_defaults(Gio::ActionMap& map) {
+    set_simple_snap(SimpleSnap::BBox, true);
+    set_simple_snap(SimpleSnap::Nodes, true);
+    set_simple_snap(SimpleSnap::Alignment, false);
+    set_simple_snap(SimpleSnap::Rest, true);
+    update_actions(map);
+}
+
+std::vector<std::vector<Glib::ustring>> raw_data_canvas_snapping =
+{
+    {"win.snap-global-toggle",        N_("Snapping"),                          "Snap",  N_("Toggle snapping on/off")                             },
+
+    {"win.snap-alignment",            N_("Snap Objects that Align"),           "Snap",  N_("Toggle alignment snapping")                          },
+    {"win.snap-alignment-self",       N_("Snap Nodes that Align"),             "Snap",  N_("Toggle alignment snapping to nodes in the same path")},
+
+    {"win.snap-distribution",         N_("Snap Objects at Equal Distances"),   "Snap",  N_("Toggle snapping objects at equal distances")},
+
+    {"win.snap-bbox",                 N_("Snap Bounding Boxes"),               "Snap",  N_("Toggle snapping to bounding boxes (global)")         },
+    {"win.snap-bbox-edge",            N_("Snap Bounding Box Edges"),           "Snap",  N_("Toggle snapping to bounding-box edges")              },
+    {"win.snap-bbox-corner",          N_("Snap Bounding Box Corners"),         "Snap",  N_("Toggle snapping to bounding-box corners")            },
+    {"win.snap-bbox-edge-midpoint",   N_("Snap Bounding Box Edge Midpoints"),  "Snap",  N_("Toggle snapping to bounding-box edge mid-points")    },
+    {"win.snap-bbox-center",          N_("Snap Bounding Box Centers"),         "Snap",  N_("Toggle snapping to bounding-box centers")            },
+
+    {"win.snap-node-category",        N_("Snap Nodes"),                        "Snap",  N_("Toggle snapping to nodes (global)")                  },
+    {"win.snap-path",                 N_("Snap Paths"),                        "Snap",  N_("Toggle snapping to paths")                           },
+    {"win.snap-path-intersection",    N_("Snap Path Intersections"),           "Snap",  N_("Toggle snapping to path intersections")              },
+    {"win.snap-node-cusp",            N_("Snap Cusp Nodes"),                   "Snap",  N_("Toggle snapping to cusp nodes, including rectangle corners")},
+    {"win.snap-node-smooth",          N_("Snap Smooth Node"),                  "Snap",  N_("Toggle snapping to smooth nodes, including quadrant points of ellipses")},
+    {"win.snap-line-midpoint",        N_("Snap Line Midpoints"),               "Snap",  N_("Toggle snapping to midpoints of lines")              },
+    {"win.snap-line-perpendicular",   N_("Snap Perpendicular Lines"),          "Snap",  N_("Toggle snapping to perpendicular lines")             },
+    {"win.snap-line-tangential",      N_("Snap Tangential Lines"),             "Snap",  N_("Toggle snapping to tangential lines")                },
+
+    {"win.snap-others",               N_("Snap Others"),                       "Snap",  N_("Toggle snapping to misc. points (global)")           },
+    {"win.snap-object-midpoint",      N_("Snap Object Midpoint"),              "Snap",  N_("Toggle snapping to object midpoint")                 },
+    {"win.snap-rotation-center",      N_("Snap Rotation Center"),              "Snap",  N_("Toggle snapping to object rotation center")          },
+    {"win.snap-text-baseline",        N_("Snap Text Baselines"),               "Snap",  N_("Toggle snapping to text baseline and text anchors")  },
+
+    {"win.snap-page-border",          N_("Snap Page Border"),                  "Snap",  N_("Toggle snapping to page border")                     },
+    {"win.snap-grid",                 N_("Snap Grids"),                        "Snap",  N_("Toggle snapping to grids")                           },
+    {"win.snap-guide",                N_("Snap Guide Lines"),                  "Snap",  N_("Toggle snapping to guide lines")                     },
+
+    {"win.snap-path-mask",            N_("Snap Mask Paths"),                   "Snap",  N_("Toggle snapping to mask paths")                      },
+    {"win.snap-path-clip",            N_("Snap Clip Paths"),                   "Snap",  N_("Toggle snapping to clip paths")                      },
+
+    {"win.simple-snap-bbox",          N_("Simple Snap Bounding Box"),          "Snap",  N_("Toggle snapping to bounding boxes")                  },
+    {"win.simple-snap-nodes",         N_("Simple Snap Nodes"),                 "Snap",  N_("Toggle snapping to nodes")                           },
+    {"win.simple-snap-alignment",     N_("Simple Snap Alignment"),             "Snap",  N_("Toggle alignment snapping")                          },
+};
+
+void add_actions_canvas_snapping(Gio::ActionMap* map) {
+    assert(map != nullptr);
+
+    map->add_action_bool(global_toggle, [=]() {
+        auto& pref = get_snapping_preferences();
+        bool enabled = !pref.getSnapEnabledGlobally();
+        pref.setSnapEnabledGlobally(enabled);
+        store_snapping_action(global_toggle, enabled);
+        update_actions(*map);
+    });
+
+    for (auto&& info : get_snap_vect()) {
+        map->add_action_bool(info.action_name, [=](){ canvas_snapping_toggle(*map, info.type); });
+    }
+
+    // Simple snapping popover
+    for (auto&& info : simple_snap_options) {
+        map->add_action_bool(info.action_name, [=](){ toggle_simple_snap_option(*map, info.option); });
+    }
+
+    // Check if there is already an application instance (GUI or non-GUI).
+    auto app = InkscapeApplication::instance();
+    if (!app) {
+        std::cerr << "add_actions_canvas_snapping: no app!" << std::endl;
+        return;
+    }
+    app->get_action_extra_data().add_data(raw_data_canvas_snapping);
+
+    update_actions(*map);
+}
+
+
+void
+set_actions_canvas_snapping_helper(Gio::ActionMap& map, Glib::ustring action_name, bool state, bool enabled)
+{
+    // Glib::RefPtr<Gio::SimpleAction> saction = map->lookup_action(action_name); NOT POSSIBLE!
+
+    // We can't enable/disable action directly! (Gio::Action can "get" enabled value but can not
+    // "set" it! We need to cast to Gio::SimpleAction)
+    Glib::RefPtr<Gio::Action> action = map.lookup_action(action_name);
+    if (!action) {
+        std::cerr << "set_actions_canvas_snapping_helper: action " << action_name << " missing!" << std::endl;
+        return;
+    }
+
+    auto simple = Glib::RefPtr<Gio::SimpleAction>::cast_dynamic(action);
+    if (!simple) {
+        std::cerr << "set_actions_canvas_snapping_helper: action " << action_name << " not SimpleAction!" << std::endl;
+        return;
+    }
+
+    simple->change_state(state);
+    simple->set_enabled(enabled);
+}
+
+void set_actions_canvas_snapping(Gio::ActionMap& map) {
+    auto& snapprefs = get_snapping_preferences();
+    bool global = snapprefs.getSnapEnabledGlobally();
+    bool alignment = snapprefs.isTargetSnappable(SNAPTARGET_ALIGNMENT_CATEGORY);
+    bool distribution = snapprefs.isTargetSnappable(SNAPTARGET_DISTRIBUTION_CATEGORY);
+    bool bbox = snapprefs.isTargetSnappable(SNAPTARGET_BBOX_CATEGORY);
+    bool node = snapprefs.isTargetSnappable(SNAPTARGET_NODE_CATEGORY);
+    bool other = snapprefs.isTargetSnappable(SNAPTARGET_OTHERS_CATEGORY);
+
+    struct { const char* action; bool state; bool enabled; } snap_options[] = {
+        { "snap-global-toggle", global, true }, // Always enabled
+
+        { "snap-alignment", alignment, global },
+        { "snap-alignment-self",     snapprefs.isSnapButtonEnabled(SNAPTARGET_ALIGNMENT_HANDLE),   global && alignment },
+
+        { "snap-distribution", distribution, global },
+
+        { "snap-bbox", bbox, global },
+        { "snap-bbox-edge",          snapprefs.isSnapButtonEnabled(SNAPTARGET_BBOX_EDGE),          global && bbox },
+        { "snap-bbox-corner",        snapprefs.isSnapButtonEnabled(SNAPTARGET_BBOX_CORNER),        global && bbox },
+        { "snap-bbox-edge-midpoint", snapprefs.isSnapButtonEnabled(SNAPTARGET_BBOX_EDGE_MIDPOINT), global && bbox },
+        { "snap-bbox-center",        snapprefs.isSnapButtonEnabled(SNAPTARGET_BBOX_MIDPOINT),      global && bbox },
+
+        { "snap-node-category", node, global },
+        { "snap-path",               snapprefs.isSnapButtonEnabled(SNAPTARGET_PATH),               global && node },
+        { "snap-path-intersection",  snapprefs.isSnapButtonEnabled(SNAPTARGET_PATH_INTERSECTION),  global && node },
+        { "snap-node-cusp",          snapprefs.isSnapButtonEnabled(SNAPTARGET_NODE_CUSP),          global && node },
+        { "snap-node-smooth",        snapprefs.isSnapButtonEnabled(SNAPTARGET_NODE_SMOOTH),        global && node },
+        { "snap-line-midpoint",      snapprefs.isSnapButtonEnabled(SNAPTARGET_LINE_MIDPOINT),      global && node },
+        { "snap-line-tangential",    snapprefs.isSnapButtonEnabled(SNAPTARGET_PATH_TANGENTIAL),    global && node },
+        { "snap-line-perpendicular", snapprefs.isSnapButtonEnabled(SNAPTARGET_PATH_PERPENDICULAR), global && node },
+
+        { "snap-others", other, global },
+        { "snap-object-midpoint",    snapprefs.isSnapButtonEnabled(SNAPTARGET_OBJECT_MIDPOINT),    global && other },
+        { "snap-rotation-center",    snapprefs.isSnapButtonEnabled(SNAPTARGET_ROTATION_CENTER),    global && other },
+        { "snap-text-baseline",      snapprefs.isSnapButtonEnabled(SNAPTARGET_TEXT_BASELINE),      global && other },
+
+        { "snap-page-border",        snapprefs.isSnapButtonEnabled(SNAPTARGET_PAGE_BORDER),        global },
+        { "snap-grid",               snapprefs.isSnapButtonEnabled(SNAPTARGET_GRID),               global },
+        { "snap-guide",              snapprefs.isSnapButtonEnabled(SNAPTARGET_GUIDE),              global },
+
+        { "snap-path-clip",          snapprefs.isSnapButtonEnabled(SNAPTARGET_PATH_CLIP),          global },
+        { "snap-path-mask",          snapprefs.isSnapButtonEnabled(SNAPTARGET_PATH_MASK),          global },
+
+        { "simple-snap-bbox", bbox, global },
+        { "simple-snap-nodes", node, global },
+        { "simple-snap-alignment", alignment, global },
+    };
+
+    for (auto&& snap : snap_options) {
+        set_actions_canvas_snapping_helper(map, snap.action, snap.state, snap.enabled);
+    }
+}
+
+/**
+ * Simple snapping groups existing "advanced" options into three easy to understand choices (bounding box, nodes, alignment snap).
+ * Behind the scene the same snapping properties to used. When entering "simple" mode those snapping properties need to be set
+ * to the correct default values; advanced mode affords complete freedom in selecting them, simple mode restricts them.
+ */
+void transition_to_simple_snapping() {
+    if (auto* dt = SP_ACTIVE_DESKTOP) {
+        if (Gio::ActionMap* map = dt->getInkscapeWindow()) {
+            apply_simple_snap_defaults(*map);
+        }
+    }
+}
+
+
+/*
+  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 :