summaryrefslogtreecommitdiffstats
path: root/src/display/control
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/display/control/README112
-rw-r--r--src/display/control/canvas-axonomgrid.cpp770
-rw-r--r--src/display/control/canvas-axonomgrid.h99
-rw-r--r--src/display/control/canvas-grid.cpp1120
-rw-r--r--src/display/control/canvas-grid.h198
-rw-r--r--src/display/control/canvas-item-bpath.cpp262
-rw-r--r--src/display/control/canvas-item-bpath.h83
-rw-r--r--src/display/control/canvas-item-buffer.h50
-rw-r--r--src/display/control/canvas-item-catchall.cpp81
-rw-r--r--src/display/control/canvas-item-catchall.h60
-rw-r--r--src/display/control/canvas-item-ctrl.cpp1221
-rw-r--r--src/display/control/canvas-item-ctrl.h107
-rw-r--r--src/display/control/canvas-item-curve.cpp236
-rw-r--r--src/display/control/canvas-item-curve.h87
-rw-r--r--src/display/control/canvas-item-drawing.cpp296
-rw-r--r--src/display/control/canvas-item-drawing.h108
-rw-r--r--src/display/control/canvas-item-enums.h87
-rw-r--r--src/display/control/canvas-item-grid.cpp122
-rw-r--r--src/display/control/canvas-item-grid.h65
-rw-r--r--src/display/control/canvas-item-group.cpp158
-rw-r--r--src/display/control/canvas-item-group.h72
-rw-r--r--src/display/control/canvas-item-guideline.cpp343
-rw-r--r--src/display/control/canvas-item-guideline.h109
-rw-r--r--src/display/control/canvas-item-quad.cpp207
-rw-r--r--src/display/control/canvas-item-quad.h69
-rw-r--r--src/display/control/canvas-item-rect.cpp353
-rw-r--r--src/display/control/canvas-item-rect.h81
-rw-r--r--src/display/control/canvas-item-rotate.cpp212
-rw-r--r--src/display/control/canvas-item-rotate.h81
-rw-r--r--src/display/control/canvas-item-text.cpp317
-rw-r--r--src/display/control/canvas-item-text.h92
-rw-r--r--src/display/control/canvas-item.cpp261
-rw-r--r--src/display/control/canvas-item.h175
-rw-r--r--src/display/control/canvas-page.cpp176
-rw-r--r--src/display/control/canvas-page.h72
-rw-r--r--src/display/control/canvas-temporary-item-list.cpp88
-rw-r--r--src/display/control/canvas-temporary-item-list.h65
-rw-r--r--src/display/control/canvas-temporary-item.cpp81
-rw-r--r--src/display/control/canvas-temporary-item.h60
-rw-r--r--src/display/control/snap-indicator.cpp640
-rw-r--r--src/display/control/snap-indicator.h85
41 files changed, 8961 insertions, 0 deletions
diff --git a/src/display/control/README b/src/display/control/README
new file mode 100644
index 0000000..680f0bf
--- /dev/null
+++ b/src/display/control/README
@@ -0,0 +1,112 @@
+
+This directory contains code for handling on-canvas editing objects as
+well as document display.
+
+Historically, the code originates from GnomeCanvas but at this point it
+has been completely rewritten for Inkscape's needs.
+
+One can think of a CanvasItem as a light-weight widget. There is a
+selection mechanism based on an item's position and a method to handle
+events. The selection mechanism is currently very simplistic,
+selecting the top-most item whose bounding box contains the
+cursor. Probably as a result, many items do not use these capabilities
+with external code replacing this functionality (e.g CanvasItemQuad,
+CanvasItemCurve).
+
+Points are stored as document coordinates. They are converted to
+screen coordinates by multiplying by the document to window affine.
+When an object's geometry changes, it must call request_update() to
+flag that its bounds need to be recalculated (_need_update =
+true). This will also cause all ancestors to also be marked and
+finally the Canvas. Before picking or drawing, all bounds must be
+up-to-date. (Changing the Canvas affine will also require bounds to be
+recalculated.) This mechanism ensures that bounds are correct in the
+most efficient manner. If only the style is changed (without geometric
+ramifications) then call canvas->redraw_area() to trigger a redraw.
+
+CanvasItemGroup keeps a list of child items using a Boost intrusive
+list. The pointers between nodes are kept inside the items. This
+allows for quick deletion by avoiding the need to search through the
+list to find the item to delete. This is important when a path
+contains hundress of nodes. However, a Boost intrusive list cannot be
+used with C++ smart pointers. Deleting an item can be done by either
+calling CanvasItemGroup::remove(CanvasItem*) or by directly deleting
+the item. Deleting a CanvasItemGroup will delete it and all of its
+children.
+
+
+Contents (x == pickable):
+
+* CanvasItem: Abstract base class.
+* CanvasItemBPath: x An item representing a Bezier path.
+* CanvasItemCatchall: x An infinite item, for capturing left-over events.
+* CanvasItemCtrl: x An item representing a control point (knot, node, etc.).
+* CanvasItemCurve: A single Bezier curve item (line or cubic). Not pickable!
+* CanvasItemDrawing: x The SVG drawing.
+* CanvasItemGrid: Base class for snapping grids.
+* CanvasItemGroup: x An item that contains other items.
+* CanvasItemGuideline: x A guideline for snapping.
+* CanvasItemQuad: An object defined by four points (only used by Text tool).
+* CanvasItemRect: An axis aligned rectangle item.
+* CanvasItemRotate: x For previewing the rotation of the canvas.
+* CanvasItemText: A text item.
+
+* CanvasItemEnum: All the enums you'll want to use!
+* CanvasItemBuffer: A class that wraps a Cairo buffer for drawing.
+
+Classes here that use CanvasItem's:
+
+* CanvasGridXY: A Cartesian grid for snapping.
+* CanvasGridAxonom An Axonometric grid for snapping.
+* SnapIndicator: A class for showing a snap possibility on canvas.
+* TemporaryItem: A class to manage the lifetime of a temporary CanvasItem.
+* TemporaryItemList: A class to track TemporaryItem's.
+
+
+Notes:
+
+CanvasItemCtrl (a.k.a. "Node", "Knot", "Handle", "Dragger", "Ctrl", "Mouse Grab", "Control Point")
+
+ Used by several groups of classes:
+
+ * Knot
+ ** KnotHolderEntity
+ *** live_effects/...
+ *** KnotHolder: Contains one or more KnotHolderEntity's.
+ Example: an object's fill and stroke gradients could have
+ overlapping knot-entities and are moved together via the knot holder.
+ **** shape-editor-knotholders.cpp
+ Classes derived from KnotHolder which contain classes derived from KnotHolderEntity for
+ editing shapes.
+ **** ShapeEditor contains two KnotHolders, one for shapes, one for LPE's.
+
+ ** ui/tools/tool-base.h
+ ** seltrans.h,.cpp
+ ** display/snap-indicator.h
+ ** gradient-drag.cpp
+ ** vanishing-point.h
+
+
+ * ControlPoint, SelectorPoint, SelectableControlPoint, Handle, Node, CurveDragPoint, TransformHandle, plus
+ auxiliary classes (manipulator...).
+ * drag-anchor
+ * pen-tool
+ * measure-tool
+ * guide-line
+ * snap-indicator
+
+
+TODO:
+
+Move files that use CanvasItem's to more appropriate places.
+
+All files that use CanvasItem's in src directory:
+* Move rubberband.h/.cpp to src/ui
+* Move gradient-drag to src/ui
+* Move selcue* to src/ui
+* Move seltrans* to src/ui
+* Move vanishing-point to src/ui
+* Move snap code to src/ui/snap display/snap-indicator.h/.cpp snap.h etc.
+
+See also src/ui/tool and src/ui/knot.
+
diff --git a/src/display/control/canvas-axonomgrid.cpp b/src/display/control/canvas-axonomgrid.cpp
new file mode 100644
index 0000000..6ec4626
--- /dev/null
+++ b/src/display/control/canvas-axonomgrid.cpp
@@ -0,0 +1,770 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Authors:
+ * Johan Engelen <j.b.c.engelen@alumnus.utwente.nl>
+ *
+ * Copyright (C) 2006-2012 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+/*
+ * Current limits are: one axis (y-axis) is always vertical. The other two
+ * axes are bound to a certain range of angles. The z-axis always has an angle
+ * smaller than 90 degrees (measured from horizontal, 0 degrees being a line extending
+ * to the right). The x-axis will always have an angle between 0 and 90 degrees.
+ */
+
+#include <gtkmm/box.h>
+#include <gtkmm/label.h>
+#include <gtkmm/grid.h>
+
+#include <glibmm/i18n.h>
+
+#include <2geom/angle.h>
+#include <2geom/line.h>
+
+#include "canvas-axonomgrid.h"
+#include "canvas-grid.h"
+#include "canvas-item-grid.h"
+
+#include "desktop.h"
+#include "document.h"
+#include "inkscape.h"
+#include "preferences.h"
+
+#include "display/cairo-utils.h"
+
+#include "helper/mathfns.h"
+
+#include "object/sp-namedview.h"
+#include "object/sp-object.h"
+#include "object/sp-root.h"
+
+#include "svg/svg-color.h"
+
+#include "ui/widget/canvas.h"
+#include "ui/widget/registered-widget.h"
+
+#include "util/units.h"
+
+using Inkscape::Util::unit_table;
+
+enum Dim3 { X=0, Y, Z };
+
+/**
+ * This function calls Cairo to render a line on a particular canvas buffer.
+ * Coordinates are interpreted as SCREENcoordinates
+ */
+static void
+sp_caxonomgrid_drawline (Inkscape::CanvasItemBuffer *buf, gint x0, gint y0, gint x1, gint y1, guint32 rgba)
+{
+ buf->cr->move_to(0.5 + x0, 0.5 + y0);
+ buf->cr->line_to(0.5 + x1, 0.5 + y1);
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(rgba), SP_RGBA32_G_F(rgba),
+ SP_RGBA32_B_F(rgba), SP_RGBA32_A_F(rgba));
+ buf->cr->stroke();
+}
+
+static void
+sp_grid_vline (Inkscape::CanvasItemBuffer *buf, gint x, gint ys, gint ye, guint32 rgba)
+{
+ if ((x < buf->rect.left()) || (x >= buf->rect.right()))
+ return;
+
+ buf->cr->move_to(0.5 + x, 0.5 + ys);
+ buf->cr->line_to(0.5 + x, 0.5 + ye);
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(rgba), SP_RGBA32_G_F(rgba),
+ SP_RGBA32_B_F(rgba), SP_RGBA32_A_F(rgba));
+ buf->cr->stroke();
+}
+
+namespace Inkscape {
+
+
+CanvasAxonomGrid::CanvasAxonomGrid (SPNamedView * nv, Inkscape::XML::Node * in_repr, SPDocument * in_doc)
+ : CanvasGrid(nv, in_repr, in_doc, GRID_AXONOMETRIC)
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gridunit = unit_table.getUnit(prefs->getString("/options/grids/axonom/units"));
+ if (!gridunit) {
+ gridunit = unit_table.getUnit("px");
+ }
+ origin[Geom::X] = Inkscape::Util::Quantity::convert(prefs->getDouble("/options/grids/axonom/origin_x", 0.0), gridunit, "px");
+ origin[Geom::Y] = Inkscape::Util::Quantity::convert(prefs->getDouble("/options/grids/axonom/origin_y", 0.0), gridunit, "px");
+ color = prefs->getInt("/options/grids/axonom/color", GRID_DEFAULT_COLOR);
+ empcolor = prefs->getInt("/options/grids/axonom/empcolor", GRID_DEFAULT_EMPCOLOR);
+ empspacing = prefs->getInt("/options/grids/axonom/empspacing", 5);
+ lengthy = Inkscape::Util::Quantity::convert(prefs->getDouble("/options/grids/axonom/spacing_y", 1.0), gridunit, "px");
+ angle_deg[X] = prefs->getDouble("/options/grids/axonom/angle_x", 30.0);
+ angle_deg[Z] = prefs->getDouble("/options/grids/axonom/angle_z", 30.0);
+ angle_deg[Y] = 0;
+
+ angle_rad[X] = Geom::rad_from_deg(angle_deg[X]);
+ tan_angle[X] = tan(angle_rad[X]);
+ angle_rad[Z] = Geom::rad_from_deg(angle_deg[Z]);
+ tan_angle[Z] = tan(angle_rad[Z]);
+
+ snapper = new CanvasAxonomGridSnapper(this, &namedview->snap_manager, 0);
+
+ if (repr) readRepr();
+}
+
+CanvasAxonomGrid::~CanvasAxonomGrid ()
+{
+ if (snapper) delete snapper;
+}
+
+static gboolean sp_nv_read_opacity(gchar const *str, guint32 *color)
+{
+ if (!str) {
+ return FALSE;
+ }
+
+ gchar *u;
+ gdouble v = g_ascii_strtod(str, &u);
+ if (!u) {
+ return FALSE;
+ }
+ v = CLAMP(v, 0.0, 1.0);
+
+ *color = (*color & 0xffffff00) | (guint32) floor(v * 255.9999);
+
+ return TRUE;
+}
+
+
+
+void
+CanvasAxonomGrid::readRepr()
+{
+ SPRoot *root = doc->getRoot();
+ double scale_x = 1.0;
+ double scale_y = 1.0;
+ if( root->viewBox_set ) {
+ scale_x = root->width.computed / root->viewBox.width();
+ scale_y = root->height.computed / root->viewBox.height();
+ if (Geom::are_near(scale_x / scale_y, 1.0, Geom::EPSILON)) {
+ // scaling is uniform, try to reduce numerical error
+ scale_x = (scale_x + scale_y)/2.0;
+ double scale_none = Inkscape::Util::Quantity::convert(1, doc->getDisplayUnit(), "px");
+ if (Geom::are_near(scale_x / scale_none, 1.0, Geom::EPSILON))
+ scale_x = scale_none; // objects are same size, reduce numerical error
+ scale_y = scale_x;
+ }
+ }
+
+ gchar const *value;
+
+ if ( (value = repr->attribute("originx")) ) {
+
+ Inkscape::Util::Quantity q = unit_table.parseQuantity(value);
+
+ if( q.unit->type == UNIT_TYPE_LINEAR ) {
+ // Legacy grid not in 'user units'
+ origin[Geom::X] = q.value("px");
+ } else {
+ // Grid in 'user units'
+ origin[Geom::X] = q.quantity * scale_x;
+ }
+ }
+
+ if ( (value = repr->attribute("originy")) ) {
+
+ Inkscape::Util::Quantity q = unit_table.parseQuantity(value);
+
+ if( q.unit->type == UNIT_TYPE_LINEAR ) {
+ // Legacy grid not in 'user units'
+ origin[Geom::Y] = q.value("px");
+ } else {
+ // Grid in 'user units'
+ origin[Geom::Y] = q.quantity * scale_y;
+ }
+ }
+
+ if ( (value = repr->attribute("spacingy")) ) {
+
+ Inkscape::Util::Quantity q = unit_table.parseQuantity(value);
+
+ if( q.unit->type == UNIT_TYPE_LINEAR ) {
+ // Legacy grid not in 'user units'
+ lengthy = q.value("px");
+ } else {
+ // Grid in 'user units'
+ lengthy = q.quantity * scale_y; // We do not handle scale_x != scale_y
+ }
+ if (lengthy < 0.0500) lengthy = 0.0500;
+ }
+
+ if ( (value = repr->attribute("gridanglex")) ) {
+ angle_deg[X] = g_ascii_strtod(value, nullptr);
+ if (angle_deg[X] < 0.) angle_deg[X] = 0.;
+ if (angle_deg[X] > 89.0) angle_deg[X] = 89.0;
+ angle_rad[X] = Geom::rad_from_deg(angle_deg[X]);
+ tan_angle[X] = tan(angle_rad[X]);
+ }
+
+ if ( (value = repr->attribute("gridanglez")) ) {
+ angle_deg[Z] = g_ascii_strtod(value, nullptr);
+ if (angle_deg[Z] < 0.) angle_deg[Z] = 0.;
+ if (angle_deg[Z] > 89.0) angle_deg[Z] = 89.0;
+ angle_rad[Z] = Geom::rad_from_deg(angle_deg[Z]);
+ tan_angle[Z] = tan(angle_rad[Z]);
+ }
+
+ if ( (value = repr->attribute("color")) ) {
+ color = (color & 0xff) | sp_svg_read_color(value, color);
+ }
+
+ if ( (value = repr->attribute("empcolor")) ) {
+ empcolor = (empcolor & 0xff) | sp_svg_read_color(value, empcolor);
+ }
+
+ if ( (value = repr->attribute("opacity")) ) {
+ sp_nv_read_opacity(value, &color);
+ }
+ if ( (value = repr->attribute("empopacity")) ) {
+ sp_nv_read_opacity(value, &empcolor);
+ }
+
+ if ( (value = repr->attribute("empspacing")) ) {
+ empspacing = atoi(value);
+ }
+
+ if ( (value = repr->attribute("visible")) ) {
+ visible = (strcmp(value,"false") != 0 && strcmp(value, "0") != 0);
+ }
+
+ if ( (value = repr->attribute("enabled")) ) {
+ g_assert(snapper != nullptr);
+ snapper->setEnabled(strcmp(value,"false") != 0 && strcmp(value, "0") != 0);
+ }
+
+ if ( (value = repr->attribute("snapvisiblegridlinesonly")) ) {
+ g_assert(snapper != nullptr);
+ snapper->setSnapVisibleOnly(strcmp(value,"false") != 0 && strcmp(value, "0") != 0);
+ }
+
+ if ( (value = repr->attribute("units")) ) {
+ gridunit = unit_table.getUnit(value); // Display unit identifier in grid menu
+ }
+
+ for (auto grid : canvas_item_grids) {
+ grid->request_update();
+ }
+
+ return;
+}
+
+/**
+ * Called when XML node attribute changed; updates dialog widgets if change was not done by widgets themselves.
+ */
+void
+CanvasAxonomGrid::onReprAttrChanged(Inkscape::XML::Node */*repr*/, gchar const */*key*/, gchar const */*oldval*/, gchar const */*newval*/, bool /*is_interactive*/)
+{
+ readRepr();
+
+ if ( ! (_wr.isUpdating()) )
+ updateWidgets();
+}
+
+Gtk::Widget *
+CanvasAxonomGrid::newSpecificWidget()
+{
+ _rumg = Gtk::manage( new Inkscape::UI::Widget::RegisteredUnitMenu(
+ _("Grid _units:"), "units", _wr, repr, doc) );
+ _rsu_ox = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalarUnit(
+ _("_Origin X:"), _("X coordinate of grid origin"), "originx",
+ *_rumg, _wr, repr, doc, Inkscape::UI::Widget::RSU_x) );
+ _rsu_oy = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalarUnit(
+ _("O_rigin Y:"), _("Y coordinate of grid origin"), "originy",
+ *_rumg, _wr, repr, doc, Inkscape::UI::Widget::RSU_y) );
+ _rsu_sy = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalarUnit(
+ _("Spacing _Y:"), _("Base length of z-axis"), "spacingy",
+ *_rumg, _wr, repr, doc, Inkscape::UI::Widget::RSU_y) );
+ _rsu_ax = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalar(
+ _("Angle X:"), _("Angle of x-axis"), "gridanglex", _wr, repr, doc ) );
+ _rsu_az = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalar(
+ _("Angle Z:"), _("Angle of z-axis"), "gridanglez", _wr, repr, doc ) );
+
+ _rcp_gcol = Gtk::manage( new Inkscape::UI::Widget::RegisteredColorPicker(
+ _("Minor grid line _color:"), _("Minor grid line color"), _("Color of the minor grid lines"),
+ "color", "opacity", _wr, repr, doc));
+ _rcp_gmcol = Gtk::manage( new Inkscape::UI::Widget::RegisteredColorPicker(
+ _("Ma_jor grid line color:"), _("Major grid line color"),
+ _("Color of the major (highlighted) grid lines"),
+ "empcolor", "empopacity", _wr, repr, doc));
+
+ _rsi = Gtk::manage( new Inkscape::UI::Widget::RegisteredSuffixedInteger(
+ _("_Major grid line every:"), "", _("lines"), "empspacing", _wr, repr, doc ) );
+
+ _rumg->set_hexpand();
+ _rsu_ox->set_hexpand();
+ _rsu_oy->set_hexpand();
+ _rsu_sy->set_hexpand();
+ _rsu_ax->set_hexpand();
+ _rsu_az->set_hexpand();
+ _rcp_gcol->set_hexpand();
+ _rcp_gmcol->set_hexpand();
+ _rsi->set_hexpand();
+
+ // set widget values
+ _wr.setUpdating (true);
+
+ _rsu_ox->setDigits(5);
+ _rsu_ox->setIncrements(0.1, 1.0);
+
+ _rsu_oy->setDigits(5);
+ _rsu_oy->setIncrements(0.1, 1.0);
+
+ _rsu_sy->setDigits(5);
+ _rsu_sy->setIncrements(0.1, 1.0);
+
+ _rumg->setUnit (gridunit->abbr);
+
+ gdouble val;
+ val = origin[Geom::X];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_ox->setValue (val);
+ val = origin[Geom::Y];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_oy->setValue (val);
+ val = lengthy;
+ double gridy = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_sy->setValue (gridy);
+
+ _rsu_ax->setValue(angle_deg[X]);
+ _rsu_az->setValue(angle_deg[Z]);
+
+ _rcp_gcol->setRgba32 (color);
+ _rcp_gmcol->setRgba32 (empcolor);
+ _rsi->setValue (empspacing);
+
+ _wr.setUpdating (false);
+
+ _rsu_ox->setProgrammatically = false;
+ _rsu_oy->setProgrammatically = false;
+
+ Gtk::Box *column = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 4));
+ column->pack_start(*_rumg, true, false);
+ column->pack_start(*_rsu_ox, true, false);
+ column->pack_start(*_rsu_oy, true, false);
+ column->pack_start(*_rsu_sy, true, false);
+ column->pack_start(*_rsu_ax, true, false);
+ column->pack_start(*_rsu_az, true, false);
+ column->pack_start(*_rcp_gcol, true, false);
+ column->pack_start(*_rcp_gmcol, true, false);
+ column->pack_start(*_rsi, true, false);
+
+ return column;
+}
+
+
+/**
+ * Update dialog widgets from object's values.
+ */
+void
+CanvasAxonomGrid::updateWidgets()
+{
+ if (_wr.isUpdating()) return;
+
+ //no widgets (grid created with the document, not with the dialog)
+ if (!_rcb_visible) return;
+
+ _wr.setUpdating (true);
+
+ _rcb_visible->setActive(visible);
+ if (snapper != nullptr) {
+ _rcb_enabled->setActive(snapper->getEnabled());
+ _rcb_snap_visible_only->setActive(snapper->getSnapVisibleOnly());
+ }
+
+ _rumg->setUnit (gridunit->abbr);
+
+ gdouble val;
+
+ val = origin[Geom::X];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_ox->setValue (val);
+
+ val = origin[Geom::Y];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_oy->setValue (val);
+
+ val = lengthy;
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_sy->setValue (val);
+
+ _rsu_ax->setValue(angle_deg[X]);
+ _rsu_az->setValue(angle_deg[Z]);
+
+ _rsu_ox->setProgrammatically = false;
+ _rsu_oy->setProgrammatically = false;
+ _rsu_sy->setProgrammatically = false;
+ _rsu_ax->setProgrammatically = false;
+ _rsu_az->setProgrammatically = false;
+
+ _rcp_gcol->setRgba32 (color);
+ _rcp_gmcol->setRgba32 (empcolor);
+ _rsi->setValue (empspacing);
+
+ _wr.setUpdating (false);
+}
+
+
+
+void
+CanvasAxonomGrid::Update (Geom::Affine const &affine, unsigned int /*flags*/)
+{
+ ow = origin * affine;
+ sw = Geom::Point(fabs(affine[0]),fabs(affine[3]));
+ sw *= lengthy;
+
+ scaled = false;
+
+ for(int dim = 0; dim < 2; dim++) {
+ gint scaling_factor = empspacing;
+
+ if (scaling_factor <= 1)
+ scaling_factor = 5;
+
+ int watchdog = 0;
+ while ( (sw[dim] < 8.0) & (watchdog < 100) ) {
+ scaled = true;
+ sw[dim] *= scaling_factor;
+ // First pass, go up to the major line spacing, then
+ // keep increasing by two.
+ scaling_factor = 2;
+ watchdog++;
+ }
+
+ }
+
+ spacing_ylines = sw[Geom::X] /(tan_angle[X] + tan_angle[Z]);
+ lyw = sw[Geom::Y];
+ lxw_x = Geom::are_near(tan_angle[X],0.) ? Geom::infinity() : sw[Geom::X] / tan_angle[X];
+ lxw_z = Geom::are_near(tan_angle[Z],0.) ? Geom::infinity() : sw[Geom::X] / tan_angle[Z];
+
+ if (empspacing == 0) {
+ scaled = true;
+ }
+}
+
+void
+CanvasAxonomGrid::Render (Inkscape::CanvasItemBuffer *buf)
+{
+ //set correct coloring, depending preference (when zoomed out, always major coloring or minor coloring)
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ guint32 _empcolor;
+ guint32 _color = color;
+ bool preference = prefs->getBool("/options/grids/no_emphasize_when_zoomedout", false);
+ if( scaled && preference ) {
+ _empcolor = color;
+ } else {
+ _empcolor = empcolor;
+ }
+
+ bool xrayactive = prefs->getBool("/desktop/xrayactive", false);
+ if (xrayactive) { //this allow good looking on xray zones
+ guint32 bg = 0xffffffff;
+ _color = SP_RGBA32_F_COMPOSE(
+ CLAMP(((1 - SP_RGBA32_A_F(_color)) * SP_RGBA32_R_F(bg)) + (SP_RGBA32_A_F(_color) * SP_RGBA32_R_F(_color)), 0.0, 1.0),
+ CLAMP(((1 - SP_RGBA32_A_F(_color)) * SP_RGBA32_G_F(bg)) + (SP_RGBA32_A_F(_color) * SP_RGBA32_G_F(_color)), 0.0, 1.0),
+ CLAMP(((1 - SP_RGBA32_A_F(_color)) * SP_RGBA32_B_F(bg)) + (SP_RGBA32_A_F(_color) * SP_RGBA32_B_F(_color)), 0.0, 1.0),
+ 1.0);
+ _empcolor = SP_RGBA32_F_COMPOSE(
+ CLAMP(((1 - SP_RGBA32_A_F(_empcolor)) * SP_RGBA32_R_F(bg)) + (SP_RGBA32_A_F(_empcolor) * SP_RGBA32_R_F(_empcolor)), 0.0, 1.0),
+ CLAMP(((1 - SP_RGBA32_A_F(_empcolor)) * SP_RGBA32_G_F(bg)) + (SP_RGBA32_A_F(_empcolor) * SP_RGBA32_G_F(_empcolor)), 0.0, 1.0),
+ CLAMP(((1 - SP_RGBA32_A_F(_empcolor)) * SP_RGBA32_B_F(bg)) + (SP_RGBA32_A_F(_empcolor) * SP_RGBA32_B_F(_empcolor)), 0.0, 1.0),
+ 1.0);
+ }
+
+ buf->cr->save();
+ buf->cr->translate(-buf->rect.left(), -buf->rect.top());
+ buf->cr->set_line_width(1.0);
+ buf->cr->set_line_cap(Cairo::LINE_CAP_SQUARE);
+
+ // gc = gridcoordinates (the coordinates calculated from the grids origin 'grid->ow'.
+ // sc = screencoordinates ( for example "buf->rect.left()" is in screencoordinates )
+ // bc = buffer patch coordinates (x=0 on left side of page, y=0 on bottom of page)
+
+ // tl = topleft ; br = bottomright
+ Geom::Point buf_tl_gc;
+ Geom::Point buf_br_gc;
+ buf_tl_gc[Geom::X] = buf->rect.left() - ow[Geom::X];
+ buf_tl_gc[Geom::Y] = buf->rect.top() - ow[Geom::Y];
+ buf_br_gc[Geom::X] = buf->rect.right() - ow[Geom::X];
+ buf_br_gc[Geom::Y] = buf->rect.bottom() - ow[Geom::Y];
+
+ // render the three separate line groups representing the main-axes
+
+ // x-axis always goes from topleft to bottomright. (0,0) - (1,1)
+ gdouble const xintercept_y_bc = (buf_tl_gc[Geom::X] * tan_angle[X]) - buf_tl_gc[Geom::Y] ;
+ gdouble const xstart_y_sc = ( xintercept_y_bc - floor(xintercept_y_bc/lyw)*lyw ) + buf->rect.top();
+ gint const xlinestart = round( (xstart_y_sc - buf_tl_gc[Geom::X]*tan_angle[X] - ow[Geom::Y]) / lyw );
+ gint xlinenum = xlinestart;
+
+ // lines starting on left side.
+
+ for (gdouble y = xstart_y_sc; y < buf->rect.bottom(); y += lyw, xlinenum++) {
+ gint const x0 = buf->rect.left();
+ gint const y0 = round(y);
+ gint x1 = x0 + round( (buf->rect.bottom() - y) / tan_angle[X] );
+ gint y1 = buf->rect.bottom();
+ if ( Geom::are_near(tan_angle[X],0.) ) {
+ x1 = buf->rect.right();
+ y1 = y0;
+ }
+
+ if (!scaled && (xlinenum % empspacing) != 0) {
+ sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, _color);
+ } else {
+ sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, _empcolor);
+ }
+ }
+ // lines starting from top side
+ if (!Geom::are_near(tan_angle[X],0.))
+ {
+ gdouble const xstart_x_sc = buf->rect.left() + (lxw_x - (xstart_y_sc - buf->rect.top()) / tan_angle[X]) ;
+ xlinenum = xlinestart-1;
+ for (gdouble x = xstart_x_sc; x < buf->rect.right(); x += lxw_x, xlinenum--) {
+ gint const y0 = buf->rect.top();
+ gint const y1 = buf->rect.bottom();
+ gint const x0 = round(x);
+ gint const x1 = x0 + round( (y1 - y0) / tan_angle[X] );
+
+ if (!scaled && (xlinenum % empspacing) != 0) {
+ sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, _color);
+ } else {
+ sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, _empcolor);
+ }
+ }
+ }
+
+ // y-axis lines (vertical)
+ gdouble const ystart_x_sc = floor (buf_tl_gc[Geom::X] / spacing_ylines) * spacing_ylines + ow[Geom::X];
+ gint const ylinestart = round((ystart_x_sc - ow[Geom::X]) / spacing_ylines);
+ gint ylinenum = ylinestart;
+ for (gdouble x = ystart_x_sc; x < buf->rect.right(); x += spacing_ylines, ylinenum++) {
+ gint const x0 = floor(x); // sp_grid_vline will add 0.5 again, so we'll pre-emptively use floor()
+ // instead of round() to avoid biasing the vertical lines to the right by half a pixel; see
+ // CanvasXYGrid::Render() for more details
+ if (!scaled && (ylinenum % empspacing) != 0) {
+ sp_grid_vline (buf, x0, buf->rect.top(), buf->rect.bottom() - 1, _color);
+ } else {
+ sp_grid_vline (buf, x0, buf->rect.top(), buf->rect.bottom() - 1, _empcolor);
+ }
+ }
+
+ // z-axis always goes from bottomleft to topright. (0,1) - (1,0)
+ gdouble const zintercept_y_bc = (buf_tl_gc[Geom::X] * -tan_angle[Z]) - buf_tl_gc[Geom::Y] ;
+ gdouble const zstart_y_sc = ( zintercept_y_bc - floor(zintercept_y_bc/lyw)*lyw ) + buf->rect.top();
+ gint const zlinestart = round( (zstart_y_sc + buf_tl_gc[Geom::X]*tan_angle[Z] - ow[Geom::Y]) / lyw );
+ gint zlinenum = zlinestart;
+ // lines starting from left side
+ gdouble next_y = zstart_y_sc;
+ for (gdouble y = zstart_y_sc; y < buf->rect.bottom(); y += lyw, zlinenum++, next_y = y) {
+ gint const x0 = buf->rect.left();
+ gint const y0 = round(y);
+ gint x1 = x0 + round( (y - buf->rect.top() ) / tan_angle[Z] );
+ gint y1 = buf->rect.top();
+ if ( Geom::are_near(tan_angle[Z],0.) ) {
+ x1 = buf->rect.right();
+ y1 = y0;
+ }
+
+ if (!scaled && (zlinenum % empspacing) != 0) {
+ sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, _color);
+ } else {
+ sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, _empcolor);
+ }
+ }
+ // draw lines from bottom-up
+ if (!Geom::are_near(tan_angle[Z],0.))
+ {
+ gdouble const zstart_x_sc = buf->rect.left() + (next_y - buf->rect.bottom()) / tan_angle[Z] ;
+ for (gdouble x = zstart_x_sc; x < buf->rect.right(); x += lxw_z, zlinenum++) {
+ gint const y0 = buf->rect.bottom();
+ gint const y1 = buf->rect.top();
+ gint const x0 = round(x);
+ gint const x1 = x0 + round(buf->rect.height() / tan_angle[Z] );
+
+ if (!scaled && (zlinenum % empspacing) != 0) {
+ sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, _color);
+ } else {
+ sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, _empcolor);
+ }
+ }
+ }
+
+ buf->cr->restore();
+}
+
+CanvasAxonomGridSnapper::CanvasAxonomGridSnapper(CanvasAxonomGrid *grid, SnapManager *sm, Geom::Coord const d) : LineSnapper(sm, d)
+{
+ this->grid = grid;
+}
+
+/**
+ * \return Snap tolerance (desktop coordinates); depends on current zoom so that it's always the same in screen pixels
+ */
+Geom::Coord CanvasAxonomGridSnapper::getSnapperTolerance() const
+{
+ SPDesktop const *dt = _snapmanager->getDesktop();
+ double const zoom = dt ? dt->current_zoom() : 1;
+ return _snapmanager->snapprefs.getGridTolerance() / zoom;
+}
+
+bool CanvasAxonomGridSnapper::getSnapperAlwaysSnap() const
+{
+ return _snapmanager->snapprefs.getGridTolerance() == 10000; //TODO: Replace this threshold of 10000 by a constant; see also tolerance-slider.cpp
+}
+
+LineSnapper::LineList
+CanvasAxonomGridSnapper::_getSnapLines(Geom::Point const &p) const
+{
+ LineList s;
+
+ if ( grid == nullptr ) {
+ return s;
+ }
+
+ SPDesktop const *dt = _snapmanager->getDesktop();
+ double ta_x = grid->tan_angle[X];
+ double ta_z = grid->tan_angle[Z];
+
+ if (dt && dt->is_yaxisdown()) {
+ std::swap(ta_x, ta_z);
+ }
+
+ double spacing_h;
+ double spacing_v;
+
+ if (getSnapVisibleOnly()) {
+ // Only snapping to visible grid lines
+ spacing_h = grid->spacing_ylines; // this is the spacing of the visible grid lines measured in screen pixels
+ spacing_v = grid->lyw; // vertical
+ // convert screen pixels to px
+ // FIXME: after we switch to snapping dist in screen pixels, this will be unnecessary
+ if (dt) {
+ spacing_h /= dt->current_zoom();
+ spacing_v /= dt->current_zoom();
+ }
+ } else {
+ // Snapping to any grid line, whether it's visible or not
+ spacing_h = grid->lengthy /(grid->tan_angle[X] + grid->tan_angle[Z]);
+ spacing_v = grid->lengthy;
+
+ }
+
+ // In an axonometric grid, any point will be surrounded by 6 grid lines:
+ // - 2 vertical grid lines, one left and one right from the point
+ // - 2 angled z grid lines, one above and one below the point
+ // - 2 angled x grid lines, one above and one below the point
+
+ // Calculate the x coordinate of the vertical grid lines
+ Geom::Coord x_max = Inkscape::Util::round_to_upper_multiple_plus(p[Geom::X], spacing_h, grid->origin[Geom::X]);
+ Geom::Coord x_min = Inkscape::Util::round_to_lower_multiple_plus(p[Geom::X], spacing_h, grid->origin[Geom::X]);
+
+ // Calculate the y coordinate of the intersection of the angled grid lines with the y-axis
+ double y_proj_along_z = p[Geom::Y] - ta_z * (p[Geom::X] - grid->origin[Geom::X]);
+ double y_proj_along_x = p[Geom::Y] + ta_x * (p[Geom::X] - grid->origin[Geom::X]);
+ double y_proj_along_z_max = Inkscape::Util::round_to_upper_multiple_plus(y_proj_along_z, spacing_v, grid->origin[Geom::Y]);
+ double y_proj_along_z_min = Inkscape::Util::round_to_lower_multiple_plus(y_proj_along_z, spacing_v, grid->origin[Geom::Y]);
+ double y_proj_along_x_max = Inkscape::Util::round_to_upper_multiple_plus(y_proj_along_x, spacing_v, grid->origin[Geom::Y]);
+ double y_proj_along_x_min = Inkscape::Util::round_to_lower_multiple_plus(y_proj_along_x, spacing_v, grid->origin[Geom::Y]);
+
+ // Calculate the versor for the angled grid lines
+ Geom::Point vers_x = Geom::Point(1, -ta_x);
+ Geom::Point vers_z = Geom::Point(1, ta_z);
+
+ // Calculate the normal for the angled grid lines
+ Geom::Point norm_x = Geom::rot90(vers_x);
+ Geom::Point norm_z = Geom::rot90(vers_z);
+
+ // The four angled grid lines form a parallelogram, enclosing the point
+ // One of the two vertical grid lines divides this parallelogram in two triangles
+ // We will now try to find out in which half (i.e. triangle) our point is, and return
+ // only the three grid lines defining that triangle
+
+ // The vertical grid line is at the intersection of two angled grid lines.
+ // Now go find that intersection!
+ Geom::Point p_x(0, y_proj_along_x_max);
+ Geom::Line line_x(p_x, p_x + vers_x);
+ Geom::Point p_z(0, y_proj_along_z_max);
+ Geom::Line line_z(p_z, p_z + vers_z);
+
+ Geom::OptCrossing inters = Geom::OptCrossing(); // empty by default
+ try
+ {
+ inters = Geom::intersection(line_x, line_z);
+ }
+ catch (Geom::InfiniteSolutions &e)
+ {
+ // We're probably dealing with parallel lines; this is useless!
+ return s;
+ }
+
+ // Determine which half of the parallelogram to use
+ bool use_left_half = true;
+ bool use_right_half = true;
+
+ if (inters) {
+ Geom::Point inters_pt = line_x.pointAt((*inters).ta);
+ use_left_half = (p[Geom::X] - grid->origin[Geom::X]) < inters_pt[Geom::X];
+ use_right_half = !use_left_half;
+ }
+
+ // Return the three grid lines which define the triangle that encloses our point
+ // If we didn't find an intersection above, all 6 grid lines will be returned
+ if (use_left_half) {
+ s.push_back(std::make_pair(norm_z, Geom::Point(grid->origin[Geom::X], y_proj_along_z_max)));
+ s.push_back(std::make_pair(norm_x, Geom::Point(grid->origin[Geom::X], y_proj_along_x_min)));
+ s.push_back(std::make_pair(Geom::Point(1, 0), Geom::Point(x_max, 0)));
+ }
+
+ if (use_right_half) {
+ s.push_back(std::make_pair(norm_z, Geom::Point(grid->origin[Geom::X], y_proj_along_z_min)));
+ s.push_back(std::make_pair(norm_x, Geom::Point(grid->origin[Geom::X], y_proj_along_x_max)));
+ s.push_back(std::make_pair(Geom::Point(1, 0), Geom::Point(x_min, 0)));
+ }
+
+ return s;
+}
+
+void CanvasAxonomGridSnapper::_addSnappedLine(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, Geom::Point const &normal_to_line, Geom::Point const &point_on_line) const
+{
+ SnappedLine dummy = SnappedLine(snapped_point, snapped_distance, source, source_num, Inkscape::SNAPTARGET_GRID, getSnapperTolerance(), getSnapperAlwaysSnap(), normal_to_line, point_on_line);
+ isr.grid_lines.push_back(dummy);
+}
+
+void CanvasAxonomGridSnapper::_addSnappedPoint(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, bool constrained_snap) const
+{
+ SnappedPoint dummy = SnappedPoint(snapped_point, source, source_num, Inkscape::SNAPTARGET_GRID, snapped_distance, getSnapperTolerance(), getSnapperAlwaysSnap(), constrained_snap, true);
+ isr.points.push_back(dummy);
+}
+
+void CanvasAxonomGridSnapper::_addSnappedLinePerpendicularly(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, bool constrained_snap) const
+{
+ SnappedPoint dummy = SnappedPoint(snapped_point, source, source_num, Inkscape::SNAPTARGET_GRID_PERPENDICULAR, snapped_distance, getSnapperTolerance(), getSnapperAlwaysSnap(), constrained_snap, true);
+ isr.points.push_back(dummy);
+}
+
+bool CanvasAxonomGridSnapper::ThisSnapperMightSnap() const
+{
+ return _snap_enabled && _snapmanager->snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_GRID);
+}
+
+
+}; // namespace Inkscape
+
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-axonomgrid.h b/src/display/control/canvas-axonomgrid.h
new file mode 100644
index 0000000..be23d5b
--- /dev/null
+++ b/src/display/control/canvas-axonomgrid.h
@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef CANVAS_AXONOMGRID_H
+#define CANVAS_AXONOMGRID_H
+
+/*
+ * Authors:
+ * Johan Engelen <j.b.c.engelen@alumnus.utwente.nl>
+ *
+ * Copyright (C) 2006-2012 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "line-snapper.h"
+#include "canvas-grid.h"
+
+class SPNamedView;
+
+namespace Inkscape {
+class CanvasItemBuffer;
+namespace XML {
+ class Node;
+};
+
+class CanvasAxonomGrid : public CanvasGrid {
+public:
+ CanvasAxonomGrid(SPNamedView * nv, Inkscape::XML::Node * in_repr, SPDocument * in_doc);
+ ~CanvasAxonomGrid() override;
+
+ void Update (Geom::Affine const &affine, unsigned int flags) override;
+ void Render (Inkscape::CanvasItemBuffer *buf) override;
+
+ void readRepr() override;
+ void onReprAttrChanged (Inkscape::XML::Node * repr, char const *key, char const *oldval, char const *newval, bool is_interactive) override;
+
+ double lengthy; /**< The lengths of the primary y-axis */
+ double angle_deg[3]; /**< Angle of each axis (note that angle[2] == 0) */
+ double angle_rad[3]; /**< Angle of each axis (note that angle[2] == 0) */
+ double tan_angle[3]; /**< tan(angle[.]) */
+
+ bool scaled; /**< Whether the grid is in scaled mode */
+
+protected:
+ friend class CanvasAxonomGridSnapper;
+
+ Geom::Point ow; /**< Transformed origin by the affine for the zoom */
+ double lyw = 1.0; /**< Transformed length y by the affine for the zoom */
+ double lxw_x = 1.0;
+ double lxw_z = 1.0;
+ double spacing_ylines = 1.0;
+
+ Geom::Point sw; /**< the scaling factors of the affine transform */
+
+ Gtk::Widget * newSpecificWidget() override;
+
+private:
+ CanvasAxonomGrid(const CanvasAxonomGrid&) = delete;
+ CanvasAxonomGrid& operator=(const CanvasAxonomGrid&) = delete;
+
+ void updateWidgets();
+
+ Inkscape::UI::Widget::RegisteredUnitMenu *_rumg;
+ Inkscape::UI::Widget::RegisteredScalarUnit *_rsu_ox;
+ Inkscape::UI::Widget::RegisteredScalarUnit *_rsu_oy;
+ Inkscape::UI::Widget::RegisteredScalarUnit *_rsu_sy;
+ Inkscape::UI::Widget::RegisteredScalar *_rsu_ax;
+ Inkscape::UI::Widget::RegisteredScalar *_rsu_az;
+ Inkscape::UI::Widget::RegisteredColorPicker *_rcp_gcol;
+ Inkscape::UI::Widget::RegisteredColorPicker *_rcp_gmcol;
+ Inkscape::UI::Widget::RegisteredSuffixedInteger *_rsi;
+};
+
+
+
+class CanvasAxonomGridSnapper : public LineSnapper
+{
+public:
+ CanvasAxonomGridSnapper(CanvasAxonomGrid *grid, SnapManager *sm, Geom::Coord const d);
+ bool ThisSnapperMightSnap() const override;
+
+ Geom::Coord getSnapperTolerance() const override; //returns the tolerance of the snapper in screen pixels (i.e. independent of zoom)
+ bool getSnapperAlwaysSnap() const override; //if true, then the snapper will always snap, regardless of its tolerance
+
+private:
+ LineList _getSnapLines(Geom::Point const &p) const override;
+ void _addSnappedLine(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, Geom::Point const &normal_to_line, const Geom::Point &point_on_line) const override;
+ void _addSnappedPoint(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, bool constrained_snap) const override;
+ void _addSnappedLinePerpendicularly(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, bool constrained_snap) const override;
+
+ CanvasAxonomGrid *grid;
+};
+
+
+}; //namespace Inkscape
+
+
+
+#endif
+
+
diff --git a/src/display/control/canvas-grid.cpp b/src/display/control/canvas-grid.cpp
new file mode 100644
index 0000000..8ca17e0
--- /dev/null
+++ b/src/display/control/canvas-grid.cpp
@@ -0,0 +1,1120 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * Cartesian grid item for the Inkscape canvas.
+ *//*
+ * Authors:
+ * see git history
+ * Copyright (C) Johan Engelen 2006-2007 <johan@shouraizou.nl>
+ * Copyright (C) Lauris Kaplinski 2000
+ * Abhishek Sharma
+ * Jon A. Cruz <jon@joncruz.org>
+ * Copyright (C) Tavmong Bah 2017 <tavmjong@free.fr>
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+/* As a general comment, I am not exactly proud of how things are done.
+ * (for example the 'enable' widget and readRepr things)
+ * It does seem to work however. I intend to clean up and sort things out later, but that can take forever...
+ * Don't be shy to correct things.
+ */
+
+#include <gtkmm/box.h>
+#include <gtkmm/label.h>
+#include <gtkmm/grid.h>
+
+#include <glibmm/i18n.h>
+
+#include "canvas-grid.h"
+#include "canvas-axonomgrid.h"
+#include "canvas-item-grid.h"
+
+#include "desktop.h"
+#include "document.h"
+#include "inkscape.h"
+#include "preferences.h"
+
+#include "display/cairo-utils.h"
+
+#include "helper/mathfns.h"
+
+#include "object/sp-namedview.h"
+#include "object/sp-object.h"
+#include "object/sp-root.h"
+
+#include "svg/stringstream.h"
+#include "svg/svg-color.h"
+
+#include "ui/icon-names.h"
+#include "ui/widget/canvas.h"
+
+#include "util/units.h"
+
+#include "xml/node-event-vector.h"
+
+using Inkscape::DocumentUndo;
+using Inkscape::Util::unit_table;
+
+namespace Inkscape {
+
+static gchar const *const grid_name[] = {
+ N_("Rectangular grid"),
+ N_("Axonometric grid")
+};
+
+static gchar const *const grid_svgname[] = {
+ "xygrid",
+ "axonomgrid"
+};
+
+// ##########################################################
+// CanvasGrid
+
+ static Inkscape::XML::NodeEventVector const _repr_events = {
+ nullptr, /* child_added */
+ nullptr, /* child_removed */
+ CanvasGrid::on_repr_attr_changed,
+ nullptr, /* content_changed */
+ nullptr /* order_changed */
+ };
+
+CanvasGrid::CanvasGrid(SPNamedView * nv, Inkscape::XML::Node * in_repr, SPDocument *in_doc, GridType type)
+ : visible(true), gridtype(type), legacy(false), pixel(false)
+{
+ repr = in_repr;
+ doc = in_doc;
+ if (repr) {
+ repr->addListener (&_repr_events, this);
+ }
+
+ namedview = nv;
+}
+
+CanvasGrid::~CanvasGrid()
+{
+ if (repr) {
+ repr->removeListenerByData (this);
+ }
+
+ if (_rcb_enabled) {
+ _rcb_enabled->remove_destroy_notify_callback(this);
+ }
+
+ for (auto grid : canvas_item_grids) {
+ delete grid;
+ }
+ canvas_item_grids.clear();
+}
+
+const char *
+CanvasGrid::getName() const
+{
+ return _(grid_name[gridtype]);
+}
+
+const char *
+CanvasGrid::getSVGName() const
+{
+ return grid_svgname[gridtype];
+}
+
+GridType
+CanvasGrid::getGridType() const
+{
+ return gridtype;
+}
+
+
+char const *
+CanvasGrid::getName(GridType type)
+{
+ return _(grid_name[type]);
+}
+
+char const *
+CanvasGrid::getSVGName(GridType type)
+{
+ return grid_svgname[type];
+}
+
+GridType
+CanvasGrid::getGridTypeFromSVGName(char const *typestr)
+{
+ if (!typestr) return GRID_RECTANGULAR;
+
+ gint t = 0;
+ for (t = GRID_MAXTYPENR; t >= 0; t--) { //this automatically defaults to grid0 which is rectangular grid
+ if (!strcmp(typestr, grid_svgname[t])) break;
+ }
+ return (GridType) t;
+}
+
+GridType
+CanvasGrid::getGridTypeFromName(char const *typestr)
+{
+ if (!typestr) return GRID_RECTANGULAR;
+
+ gint t = 0;
+ for (t = GRID_MAXTYPENR; t >= 0; t--) { //this automatically defaults to grid0 which is rectangular grid
+ if (!strcmp(typestr, _(grid_name[t]))) break;
+ }
+ return (GridType) t;
+}
+
+
+/*
+* writes an <inkscape:grid> child to repr.
+*/
+void
+CanvasGrid::writeNewGridToRepr(Inkscape::XML::Node * repr, SPDocument * doc, GridType gridtype)
+{
+ if (!repr) return;
+ if (gridtype > GRID_MAXTYPENR) return;
+
+ // first create the child xml node, then hook it to repr. This order is important, to not set off listeners to repr before the new node is complete.
+
+ Inkscape::XML::Document *xml_doc = doc->getReprDoc();
+ Inkscape::XML::Node *newnode;
+ newnode = xml_doc->createElement("inkscape:grid");
+ newnode->setAttribute("type", getSVGName(gridtype));
+
+ repr->appendChild(newnode);
+ Inkscape::GC::release(newnode);
+
+ DocumentUndo::done(doc, _("Create new grid"), INKSCAPE_ICON("document-properties"));
+}
+
+/*
+* Creates a new CanvasGrid object of type gridtype
+*/
+CanvasGrid*
+CanvasGrid::NewGrid(SPNamedView * nv, Inkscape::XML::Node * repr, SPDocument * doc, GridType gridtype)
+{
+ if (!repr) return nullptr;
+ if (!doc) {
+ g_error("CanvasGrid::NewGrid - doc==NULL");
+ return nullptr;
+ }
+
+ switch (gridtype) {
+ case GRID_RECTANGULAR:
+ return new CanvasXYGrid(nv, repr, doc);
+ case GRID_AXONOMETRIC:
+ return new CanvasAxonomGrid(nv, repr, doc);
+ }
+
+ return nullptr;
+}
+
+
+/**
+* creates a new grid canvasitem for the SPDesktop given as parameter. Keeps a link to this canvasitem in the canvas_item_grids list.
+*/
+Inkscape::CanvasItemGrid *
+CanvasGrid::createCanvasItem(SPDesktop * desktop)
+{
+ if (!desktop) return nullptr;
+// Johan: I think for multiple desktops it is best if each has their own canvasitem,
+// but share the same CanvasGrid object; that is what this function is for.
+
+ // check if there is already a canvasitem on this desktop linking to this grid
+ for (auto grid : canvas_item_grids) {
+ if ( desktop->getCanvasGrids() == grid->get_parent() ) {
+ return nullptr;
+ }
+ }
+
+ Inkscape::CanvasItemGrid *grid = new Inkscape::CanvasItemGrid(desktop->getCanvasGrids(), this);
+ grid->show();
+ canvas_item_grids.push_back(grid);
+ return grid;
+}
+
+/**
+ * Remove a CanvasGridItem from vector. Does NOT delete CanvasGridItem.
+ * This is used by the CanvasGridItem destructor to ensure no dangling pointer is left.
+ */
+void
+CanvasGrid::removeCanvasItem(Inkscape::CanvasItemGrid *item)
+{
+ auto it = std::find(canvas_item_grids.begin(), canvas_item_grids.end(), item);
+ if (it != canvas_item_grids.end()) {
+ canvas_item_grids.erase(it);
+ }
+}
+
+Gtk::Widget *
+CanvasGrid::newWidget()
+{
+ Gtk::Box * vbox = Gtk::manage( new Gtk::Box(Gtk::ORIENTATION_VERTICAL) );
+ Gtk::Label * namelabel = Gtk::manage(new Gtk::Label("", Gtk::ALIGN_CENTER) );
+
+ Glib::ustring str("<b>");
+ str += getName();
+ str += "</b>";
+ namelabel->set_markup(str);
+ vbox->pack_start(*namelabel, false, false);
+
+ _rcb_enabled = Gtk::manage( new Inkscape::UI::Widget::RegisteredCheckButton(
+ _("_Enabled"),
+ _("Makes the grid available for working with on the canvas."),
+ "enabled", _wr, false, repr, doc) );
+ // _rcb_enabled serves as a canary that tells us that the widgets have been destroyed
+ _rcb_enabled->add_destroy_notify_callback(this, &CanvasGrid::notifyWidgetsDestroyed);
+
+ _rcb_snap_visible_only = Gtk::manage( new Inkscape::UI::Widget::RegisteredCheckButton(
+ _("Snap to visible _grid lines only"),
+ _("When zoomed out, not all grid lines will be displayed. Only the visible ones will be snapped to"),
+ "snapvisiblegridlinesonly", _wr, false, repr, doc) );
+
+ _rcb_visible = Gtk::manage( new Inkscape::UI::Widget::RegisteredCheckButton(
+ _("_Visible"),
+ _("Determines whether the grid is displayed or not. Objects are still snapped to invisible grids."),
+ "visible", _wr, false, repr, doc) );
+
+ _as_alignment = Gtk::manage( new Inkscape::UI::Widget::AlignmentSelector() );
+ _as_alignment->on_alignmentClicked().connect(sigc::mem_fun(*this, &CanvasGrid::align_clicked));
+
+ Gtk::Box *left = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 4));
+ left->pack_start(*_rcb_enabled, false, false);
+ left->pack_start(*_rcb_visible, false, false);
+ left->pack_start(*_rcb_snap_visible_only, false, false);
+
+ if (getGridType() == GRID_RECTANGULAR) {
+ _rcb_dotted = Gtk::manage( new Inkscape::UI::Widget::RegisteredCheckButton(
+ _("_Show dots instead of lines"), _("If set, displays dots at gridpoints instead of gridlines"),
+ "dotted", _wr, false, repr, doc) );
+ _rcb_dotted->setActive(render_dotted);
+ left->pack_start(*_rcb_dotted, false, false);
+ }
+
+ left->pack_start(*Gtk::manage(new Gtk::Label(_("Align to page:"))), false, false);
+ left->pack_start(*_as_alignment, false, false);
+
+ auto right = newSpecificWidget();
+ right->set_hexpand(false);
+
+ Gtk::Box *inner = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 4));
+ inner->pack_start(*left, true, true);
+ inner->pack_start(*right, false, false);
+ vbox->pack_start(*inner, false, false);
+ vbox->set_border_width(4);
+
+ std::list<Gtk::Widget*> slaves;
+ for (auto &item : left->get_children()) {
+ if (item != _rcb_enabled) {
+ slaves.push_back(item);
+ }
+ }
+ slaves.push_back(right);
+ _rcb_enabled->setSlaveWidgets(slaves);
+
+ // set widget values
+ _wr.setUpdating (true);
+ _rcb_visible->setActive(visible);
+ if (snapper != nullptr) {
+ _rcb_enabled->setActive(snapper->getEnabled());
+ _rcb_snap_visible_only->setActive(snapper->getSnapVisibleOnly());
+ }
+ _wr.setUpdating (false);
+ return dynamic_cast<Gtk::Widget *> (vbox);
+}
+
+/**
+ * @brief Zeroes out our pointers to the widgets when the widgets are destroyed
+ * @param data - a pointer to the CanvasGrid object holding the widget pointers
+ * @return always returns nullptr
+ */
+void *CanvasGrid::notifyWidgetsDestroyed(void *data)
+{
+ CanvasGrid *obj = (CanvasGrid *)(data);
+ obj->_rcb_enabled = nullptr;
+ obj->_rcb_snap_visible_only = nullptr;
+ obj->_rcb_visible = nullptr;
+ obj->_rcb_dotted = nullptr;
+ obj->_as_alignment = nullptr;
+ return nullptr;
+}
+
+void
+CanvasGrid::on_repr_attr_changed(Inkscape::XML::Node *repr, gchar const *key, gchar const *oldval, gchar const *newval, bool is_interactive, void *data)
+{
+ if (!data)
+ return;
+
+ (static_cast<CanvasGrid*>(data))->onReprAttrChanged(repr, key, oldval, newval, is_interactive);
+}
+
+bool CanvasGrid::isEnabled() const
+{
+ if (snapper == nullptr) {
+ return false;
+ }
+
+ return snapper->getEnabled();
+}
+
+// Used to shift origin when page size changed to fit drawing.
+void CanvasGrid::setOrigin(Geom::Point const &origin_px)
+{
+ SPRoot *root = doc->getRoot();
+ double scale_x = 1.0;
+ double scale_y = 1.0;
+ if( root->viewBox_set ) {
+ scale_x = root->viewBox.width() / root->width.computed;
+ scale_y = root->viewBox.height() / root->height.computed;
+ }
+
+ // Write out in 'user-units'
+ Inkscape::SVGOStringStream os_x, os_y;
+ os_x << origin_px[Geom::X] * scale_x;
+ os_y << origin_px[Geom::Y] * scale_y;
+ repr->setAttribute("originx", os_x.str());
+ repr->setAttribute("originy", os_y.str());
+}
+
+void CanvasGrid::align_clicked(int align)
+{
+ Geom::Point dimensions = doc->getDimensions();
+ dimensions[Geom::X] *= align % 3 * 0.5;
+ dimensions[Geom::Y] *= align / 3 * 0.5;
+ dimensions *= doc->doc2dt();
+ setOrigin(dimensions);
+}
+
+
+
+// ##########################################################
+// CanvasXYGrid
+
+CanvasXYGrid::CanvasXYGrid (SPNamedView * nv, Inkscape::XML::Node * in_repr, SPDocument * in_doc)
+ : CanvasGrid(nv, in_repr, in_doc, GRID_RECTANGULAR)
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gridunit = unit_table.getUnit(prefs->getString("/options/grids/xy/units"));
+ if (!gridunit) {
+ gridunit = unit_table.getUnit("px");
+ }
+ origin[Geom::X] = Inkscape::Util::Quantity::convert(prefs->getDouble("/options/grids/xy/origin_x", 0.0), gridunit, "px");
+ origin[Geom::Y] = Inkscape::Util::Quantity::convert(prefs->getDouble("/options/grids/xy/origin_y", 0.0), gridunit, "px");
+ color = prefs->getInt("/options/grids/xy/color", GRID_DEFAULT_COLOR);
+ empcolor = prefs->getInt("/options/grids/xy/empcolor", GRID_DEFAULT_EMPCOLOR);
+ empspacing = prefs->getInt("/options/grids/xy/empspacing", 5);
+ spacing[Geom::X] = Inkscape::Util::Quantity::convert(prefs->getDouble("/options/grids/xy/spacing_x", 0.0), gridunit, "px");
+ spacing[Geom::Y] = Inkscape::Util::Quantity::convert(prefs->getDouble("/options/grids/xy/spacing_y", 0.0), gridunit, "px");
+ render_dotted = prefs->getBool("/options/grids/xy/dotted", false);
+
+ snapper = new CanvasXYGridSnapper(this, &namedview->snap_manager, 0);
+
+ if (repr) readRepr();
+}
+
+CanvasXYGrid::~CanvasXYGrid ()
+{
+ if (snapper) delete snapper;
+}
+
+static gboolean sp_nv_read_opacity(gchar const *str, guint32 *color)
+{
+ if (!str) {
+ return FALSE;
+ }
+
+ gchar *u;
+ gdouble v = g_ascii_strtod(str, &u);
+ if (!u) {
+ return FALSE;
+ }
+ v = CLAMP(v, 0.0, 1.0);
+
+ *color = (*color & 0xffffff00) | (guint32) floor(v * 255.9999);
+
+ return TRUE;
+}
+
+/** If the passed int is invalid (<=0), then set the widget and the int
+ to use the given old value.
+
+ @param oldVal Old value to use if the new one is invalid.
+ @param pTarget The int to validate.
+ @param widget Widget associated with the int.
+*/
+static void validateInt(gint oldVal,
+ gint* pTarget)
+{
+ // Avoid nullness.
+ if ( pTarget == nullptr )
+ return;
+
+ // Invalid new value?
+ if ( *pTarget <= 0 ) {
+ // If the old value is somehow invalid as well, then default to 1.
+ if ( oldVal <= 0 )
+ oldVal = 1;
+
+ // Reset the int and associated widget to the old value.
+ *pTarget = oldVal;
+ } //if
+
+} //validateInt
+
+void
+CanvasXYGrid::readRepr()
+{
+ SPRoot *root = doc->getRoot();
+ double scale_x = 1.0;
+ double scale_y = 1.0;
+ if( root->viewBox_set ) {
+ scale_x = root->width.computed / root->viewBox.width();
+ scale_y = root->height.computed / root->viewBox.height();
+ if (Geom::are_near(scale_x / scale_y, 1.0, Geom::EPSILON)) {
+ // scaling is uniform, try to reduce numerical error
+ scale_x = (scale_x + scale_y)/2.0;
+ double scale_none = Inkscape::Util::Quantity::convert(1, doc->getDisplayUnit(), "px");
+ if (Geom::are_near(scale_x / scale_none, 1.0, Geom::EPSILON))
+ scale_x = scale_none; // objects are same size, reduce numerical error
+ scale_y = scale_x;
+ }
+ }
+
+ gchar const *value;
+
+ if ( (value = repr->attribute("originx")) ) {
+
+ Inkscape::Util::Quantity q = unit_table.parseQuantity(value);
+
+ if( q.unit->type == UNIT_TYPE_LINEAR ) {
+ // Legacy grid not in 'user units'
+ origin[Geom::X] = q.value("px");
+ legacy = true;
+ if (q.unit->abbr == "px" ) {
+ pixel = true;
+ }
+ } else {
+ // Grid in 'user units'
+ origin[Geom::X] = q.quantity * scale_x;
+ }
+ }
+
+ if ( (value = repr->attribute("originy")) ) {
+
+ Inkscape::Util::Quantity q = unit_table.parseQuantity(value);
+
+ if( q.unit->type == UNIT_TYPE_LINEAR ) {
+ // Legacy grid not in 'user units'
+ origin[Geom::Y] = q.value("px");
+ legacy = true;
+ if (q.unit->abbr == "px" ) {
+ pixel = true;
+ }
+ } else {
+ // Grid in 'user units'
+ origin[Geom::Y] = q.quantity * scale_y;
+ }
+ }
+
+ if ( (value = repr->attribute("spacingx")) ) {
+
+ // Ensure a valid default value
+ if( spacing[Geom::X] <= 0.0 )
+ spacing[Geom::X] = 1.0;
+
+ Inkscape::Util::Quantity q = unit_table.parseQuantity(value);
+ // Ensure a valid new value
+ if( q.quantity > 0 ) {
+ if( q.unit->type == UNIT_TYPE_LINEAR ) {
+ // Legacy grid not in 'user units'
+ spacing[Geom::X] = q.value("px");
+ legacy = true;
+ if (q.unit->abbr == "px" ) {
+ pixel = true;
+ }
+ } else {
+ // Grid in 'user units'
+ spacing[Geom::X] = q.quantity * scale_x;
+ }
+ }
+ }
+
+ if ( (value = repr->attribute("spacingy")) ) {
+
+ // Ensure a valid default value
+ if( spacing[Geom::Y] <= 0.0 )
+ spacing[Geom::Y] = 1.0;
+
+ Inkscape::Util::Quantity q = unit_table.parseQuantity(value);
+ // Ensure a valid new value
+ if( q.quantity > 0 ) {
+ if( q.unit->type == UNIT_TYPE_LINEAR ) {
+ // Legacy grid not in 'user units'
+ spacing[Geom::Y] = q.value("px");
+ legacy = true;
+ if (q.unit->abbr == "px" ) {
+ pixel = true;
+ }
+ } else {
+ // Grid in 'user units'
+ spacing[Geom::Y] = q.quantity * scale_y;
+ }
+ }
+ }
+
+ if ( (value = repr->attribute("color")) ) {
+ color = (color & 0xff) | sp_svg_read_color(value, color);
+ }
+
+ if ( (value = repr->attribute("empcolor")) ) {
+ empcolor = (empcolor & 0xff) | sp_svg_read_color(value, empcolor);
+ }
+
+ if ( (value = repr->attribute("opacity")) ) {
+ sp_nv_read_opacity(value, &color);
+ }
+ if ( (value = repr->attribute("empopacity")) ) {
+ sp_nv_read_opacity(value, &empcolor);
+ }
+
+ if ( (value = repr->attribute("empspacing")) ) {
+ gint oldVal = empspacing;
+ empspacing = atoi(value);
+ validateInt( oldVal, &empspacing);
+ }
+
+ if ( (value = repr->attribute("dotted")) ) {
+ render_dotted = (strcmp(value,"false") != 0 && strcmp(value, "0") != 0);
+ }
+
+ if ( (value = repr->attribute("visible")) ) {
+ visible = (strcmp(value,"false") != 0 && strcmp(value, "0") != 0);
+ }
+
+ if ( (value = repr->attribute("enabled")) ) {
+ g_assert(snapper != nullptr);
+ snapper->setEnabled(strcmp(value,"false") != 0 && strcmp(value, "0") != 0);
+ }
+
+ if ( (value = repr->attribute("snapvisiblegridlinesonly")) ) {
+ g_assert(snapper != nullptr);
+ snapper->setSnapVisibleOnly(strcmp(value,"false") != 0 && strcmp(value, "0") != 0);
+ }
+
+ if ( (value = repr->attribute("units")) ) {
+ gridunit = unit_table.getUnit(value); // Display unit identifier in grid menu
+ }
+
+ for (auto grid : canvas_item_grids) {
+ grid->request_update();
+ }
+
+ return;
+}
+
+/**
+ * Called when XML node attribute changed; updates dialog widgets if change was not done by widgets themselves.
+ */
+void
+CanvasXYGrid::onReprAttrChanged(Inkscape::XML::Node */*repr*/, gchar const */*key*/, gchar const */*oldval*/, gchar const */*newval*/, bool /*is_interactive*/)
+{
+ readRepr();
+ updateWidgets();
+}
+
+
+Gtk::Widget *
+CanvasXYGrid::newSpecificWidget()
+{
+ _rumg = Gtk::manage( new Inkscape::UI::Widget::RegisteredUnitMenu(
+ _("Grid _units:"), "units", _wr, repr, doc) );
+ _rsu_ox = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalarUnit(
+ _("_Origin X:"), _("X coordinate of grid origin"), "originx",
+ *_rumg, _wr, repr, doc, Inkscape::UI::Widget::RSU_x) );
+ _rsu_oy = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalarUnit(
+ _("O_rigin Y:"), _("Y coordinate of grid origin"), "originy",
+ *_rumg, _wr, repr, doc, Inkscape::UI::Widget::RSU_y) );
+ _rsu_sx = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalarUnit(
+ _("Spacing _X:"), _("Distance between vertical grid lines"), "spacingx",
+ *_rumg, _wr, repr, doc, Inkscape::UI::Widget::RSU_x) );
+ _rsu_sy = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalarUnit(
+ _("Spacing _Y:"), _("Distance between horizontal grid lines"), "spacingy",
+ *_rumg, _wr, repr, doc, Inkscape::UI::Widget::RSU_y) );
+
+ _rcp_gcol = Gtk::manage( new Inkscape::UI::Widget::RegisteredColorPicker(
+ _("Minor grid line _color:"), _("Minor grid line color"), _("Color of the minor grid lines"),
+ "color", "opacity", _wr, repr, doc) );
+
+ _rcp_gmcol = Gtk::manage( new Inkscape::UI::Widget::RegisteredColorPicker(
+ _("Ma_jor grid line color:"), _("Major grid line color"),
+ _("Color of the major (highlighted) grid lines"), "empcolor", "empopacity",
+ _wr, repr, doc) );
+
+ _rsi = Gtk::manage( new Inkscape::UI::Widget::RegisteredSuffixedInteger(
+ _("_Major grid line every:"), "", _("lines"), "empspacing", _wr, repr, doc) );
+
+ _rumg->set_hexpand();
+ _rsu_ox->set_hexpand();
+ _rsu_oy->set_hexpand();
+ _rsu_sx->set_hexpand();
+ _rsu_sy->set_hexpand();
+ _rcp_gcol->set_hexpand();
+ _rcp_gmcol->set_hexpand();
+ _rsi->set_hexpand();
+
+ // set widget values
+ _wr.setUpdating (true);
+
+ _rsu_ox->setDigits(5);
+ _rsu_ox->setIncrements(0.1, 1.0);
+
+ _rsu_oy->setDigits(5);
+ _rsu_oy->setIncrements(0.1, 1.0);
+
+ _rsu_sx->setDigits(5);
+ _rsu_sx->setIncrements(0.1, 1.0);
+
+ _rsu_sy->setDigits(5);
+ _rsu_sy->setIncrements(0.1, 1.0);
+
+ _rumg->setUnit (gridunit->abbr);
+
+ gdouble val;
+ val = origin[Geom::X];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_ox->setValue (val);
+ val = origin[Geom::Y];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_oy->setValue (val);
+ val = spacing[Geom::X];
+ double gridx = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_sx->setValue (gridx);
+ val = spacing[Geom::Y];
+ double gridy = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_sy->setValue (gridy);
+
+ _rcp_gcol->setRgba32 (color);
+ _rcp_gmcol->setRgba32 (empcolor);
+ _rsi->setValue (empspacing);
+
+ _wr.setUpdating (false);
+
+ _rsu_ox->setProgrammatically = false;
+ _rsu_oy->setProgrammatically = false;
+ _rsu_sx->setProgrammatically = false;
+ _rsu_sy->setProgrammatically = false;
+
+ Gtk::Box *column = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 4));
+ column->pack_start(*_rumg, true, false);
+ column->pack_start(*_rsu_ox, true, false);
+ column->pack_start(*_rsu_oy, true, false);
+ column->pack_start(*_rsu_sx, true, false);
+ column->pack_start(*_rsu_sy, true, false);
+ column->pack_start(*_rcp_gcol, true, false);
+ column->pack_start(*_rcp_gmcol, true, false);
+ column->pack_start(*_rsi, true, false);
+
+ return column;
+}
+
+
+/**
+ * Update dialog widgets from object's values.
+ */
+void
+CanvasXYGrid::updateWidgets()
+{
+ if (_wr.isUpdating()) return;
+
+ //no widgets (grid created with the document, not with the dialog)
+ if (!_rcb_visible) return;
+
+ _wr.setUpdating (true);
+
+ _rcb_visible->setActive(visible);
+ if (snapper != nullptr) {
+ _rcb_enabled->setActive(snapper->getEnabled());
+ _rcb_snap_visible_only->setActive(snapper->getSnapVisibleOnly());
+ }
+
+ _rumg->setUnit (gridunit->abbr);
+
+ gdouble val;
+
+ val = origin[Geom::X];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_ox->setValue (val);
+
+ val = origin[Geom::Y];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_oy->setValue (val);
+
+ val = spacing[Geom::X];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_sx->setValue (val);
+
+ val = spacing[Geom::Y];
+ val = Inkscape::Util::Quantity::convert(val, "px", gridunit);
+ _rsu_sy->setValue (val);
+
+ _rsu_ox->setProgrammatically = false;
+ _rsu_oy->setProgrammatically = false;
+ _rsu_sx->setProgrammatically = false;
+ _rsu_sy->setProgrammatically = false;
+
+ _rcp_gcol->setRgba32 (color);
+ _rcp_gmcol->setRgba32 (empcolor);
+ _rsi->setValue (empspacing);
+ _rcb_dotted->setActive (render_dotted);
+
+ _wr.setUpdating (false);
+}
+
+// For correcting old SVG Inkscape files
+void
+CanvasXYGrid::Scale (Geom::Scale const &scale ) {
+ origin *= scale;
+ spacing *= scale;
+
+ // Write out in 'user-units'
+ Inkscape::SVGOStringStream os_x, os_y, ss_x, ss_y;
+ os_x << origin[Geom::X];
+ os_y << origin[Geom::Y];
+ ss_x << spacing[Geom::X];
+ ss_y << spacing[Geom::Y];
+ repr->setAttribute("originx", os_x.str());
+ repr->setAttribute("originy", os_y.str());
+ repr->setAttribute("spacingx", ss_x.str());
+ repr->setAttribute("spacingy", ss_y.str());
+}
+
+void
+CanvasXYGrid::Update (Geom::Affine const &affine, unsigned int /*flags*/)
+{
+ ow = origin * affine;
+ sw[0] = Geom::Point(spacing[0], 0) * affine.withoutTranslation();
+ sw[1] = Geom::Point(0, spacing[1]) * affine.withoutTranslation();
+
+ // Find suitable grid spacing for display
+ for(int dim = 0; dim < 2; dim++) {
+ gint scaling_factor = empspacing;
+
+ if (scaling_factor <= 1)
+ scaling_factor = 5;
+
+ scaled[dim] = false;
+ while (fabs(sw[dim].length()) < 8.0) {
+ scaled[dim] = true;
+ sw[dim] *= scaling_factor;
+ /* First pass, go up to the major line spacing, then
+ keep increasing by two. */
+ scaling_factor = 2;
+ }
+ }
+}
+
+
+// Find intersections of line with rectangle. There should be zero or two.
+// If line is degenerate with rectangle side, two corner points are returned.
+static std::vector<Geom::Point>
+intersect_line_rectangle( Geom::Line const &line, Geom::Rect const &rect )
+{
+ std::vector<Geom::Point> intersections;
+ for (unsigned i = 0; i < 4; ++i) {
+ Geom::LineSegment side( rect.corner(i), rect.corner((i+1)%4) );
+ try {
+ Geom::OptCrossing oc = Geom::intersection(line, side);
+ if (oc) {
+ intersections.push_back( line.pointAt((*oc).ta));
+ }
+ } catch (Geom::InfiniteSolutions) {
+ intersections.clear();
+ intersections.push_back( side.pointAt(0) );
+ intersections.push_back( side.pointAt(1) );
+ return intersections;
+ }
+ }
+ return intersections;
+}
+
+// Find the signed distance of a point to a line. The distance is negative if
+// the point lies to the left of the line considering the line's versor.
+static double
+signed_distance( Geom::Point const &point, Geom::Line const &line ) {
+ Geom::Coord t = line.nearestTime( point );
+ Geom::Point p = line.pointAt(t);
+ double distance = Geom::distance( p, point );
+ if ( Geom::cross( Geom::Line( p, point ).versor(), line.versor() ) < 0.0 ) {
+ distance = -distance;
+ }
+ return distance;
+}
+
+void
+CanvasXYGrid::Render (Inkscape::CanvasItemBuffer *buf)
+{
+
+ // no_emphasize_when_zoomedout determines color (minor or major) when only major grid lines/dots shown.
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ guint32 _empcolor;
+ guint32 _color = color;
+ bool no_emp_when_zoomed_out = prefs->getBool("/options/grids/no_emphasize_when_zoomedout", false);
+ if( (scaled[Geom::X] || scaled[Geom::Y]) && no_emp_when_zoomed_out ) {
+ _empcolor = color;
+ } else {
+ _empcolor = empcolor;
+ }
+
+ bool xrayactive = prefs->getBool("/desktop/xrayactive", false);
+ if (xrayactive) {
+ guint32 bg = 0xffffffff;
+ _color = SP_RGBA32_F_COMPOSE(
+ CLAMP(((1 - SP_RGBA32_A_F(_color)) * SP_RGBA32_R_F(bg)) + (SP_RGBA32_A_F(_color) * SP_RGBA32_R_F(_color)), 0.0, 1.0),
+ CLAMP(((1 - SP_RGBA32_A_F(_color)) * SP_RGBA32_G_F(bg)) + (SP_RGBA32_A_F(_color) * SP_RGBA32_G_F(_color)), 0.0, 1.0),
+ CLAMP(((1 - SP_RGBA32_A_F(_color)) * SP_RGBA32_B_F(bg)) + (SP_RGBA32_A_F(_color) * SP_RGBA32_B_F(_color)), 0.0, 1.0),
+ 1.0);
+ _empcolor = SP_RGBA32_F_COMPOSE(
+ CLAMP(((1 - SP_RGBA32_A_F(_empcolor)) * SP_RGBA32_R_F(bg)) + (SP_RGBA32_A_F(_empcolor) * SP_RGBA32_R_F(_empcolor)), 0.0, 1.0),
+ CLAMP(((1 - SP_RGBA32_A_F(_empcolor)) * SP_RGBA32_G_F(bg)) + (SP_RGBA32_A_F(_empcolor) * SP_RGBA32_G_F(_empcolor)), 0.0, 1.0),
+ CLAMP(((1 - SP_RGBA32_A_F(_empcolor)) * SP_RGBA32_B_F(bg)) + (SP_RGBA32_A_F(_empcolor) * SP_RGBA32_B_F(_empcolor)), 0.0, 1.0),
+ 1.0);
+ }
+
+ buf->cr->save();
+ buf->cr->translate(-buf->rect.left(), -buf->rect.top());
+ buf->cr->set_line_width(1.0);
+ buf->cr->set_line_cap(Cairo::LINE_CAP_SQUARE);
+
+ // Adding a 2 px margin to the buffer rectangle to avoid missing intersections (in case of rounding errors, and due to adding 0.5 below)
+ Geom::IntRect buf_rect_with_margin = buf->rect;
+ buf_rect_with_margin.expandBy(2);
+
+ for (unsigned dim = 0; dim < 2; ++dim) {
+
+ // std::cout << "\n " << (dim==0?"Horizontal":"Vertical") << " ------------" << std::endl;
+
+ // Construct an axis line through origin with direction normal to grid spacing.
+ Geom::Line axis = Geom::Line::from_origin_and_vector( ow, sw[dim] );
+ Geom::Line orth = Geom::Line::from_origin_and_vector( ow, sw[(dim+1)%2] );
+
+ double spacing = sw[(dim+1)%2].length(); // Spacing between grid lines.
+ double dash = sw[dim].length(); // Total length of dash pattern.
+
+ // std::cout << " axis: " << axis.origin() << ", " << axis.vector() << std::endl;
+ // std::cout << " spacing: " << spacing << std::endl;
+ // std::cout << " dash period: " << dash << std::endl;
+
+ // Find the minimum and maximum distances of the buffer corners from axis.
+ double min = Geom::infinity();
+ double max = -Geom::infinity();
+ for (unsigned c = 0; c < 4; ++c) {
+
+ // We need signed distance... lib2geom offers only positive distance.
+ double distance = signed_distance( buf_rect_with_margin.corner(c), axis );
+
+ // Correct it for coordinate flips (inverts handedness).
+ if (Geom::cross( axis.vector(), orth.vector() ) > 0 ) {
+ distance = -distance;
+ }
+
+ if (distance < min)
+ min = distance;
+ if (distance > max)
+ max = distance;
+ }
+ int start = floor( min/spacing );
+ int stop = floor( max/spacing );
+
+ // std::cout << " rect: " << buf->rect << std::endl;
+ // std::cout << " min: " << min << " max: " << max << std::endl;
+ // std::cout << " start: " << start << " stop: " << stop << std::endl;
+
+ // Loop over grid lines that intersected buf rectangle.
+ for (int j = start+1; j <= stop; ++j) {
+
+ Geom::Line grid_line = Geom::make_parallel_line( ow + j * sw[(dim+1)%2], axis );
+
+ std::vector<Geom::Point> x = intersect_line_rectangle( grid_line, buf_rect_with_margin );
+
+ // If we have two intersections, grid line intersects buffer rectangle.
+ if (x.size() == 2 ) {
+ // Make sure lines are always drawn in the same direction (or dashes misplaced).
+ Geom::Line vector( x[0], x[1]);
+ if (Geom::dot( vector.vector(), axis.vector() ) < 0.0) {
+ std::swap(x[0], x[1]);
+ }
+
+ // Set up line. Need to use floor()+0.5 such that Cairo will draw us lines with a width of a single pixel, without any aliasing.
+ // For this we need to position the lines at exactly half pixels, see https://www.cairographics.org/FAQ/#sharp_lines
+ // Must be consistent with the pixel alignment of the guide lines, see CanvasXYGrid::Render(), and the drawing of the rulers
+ buf->cr->move_to(floor(x[0][Geom::X]) + 0.5, floor(x[0][Geom::Y]) + 0.5);
+ buf->cr->line_to(floor(x[1][Geom::X]) + 0.5, floor(x[1][Geom::Y]) + 0.5);
+
+ // Set dash pattern and color.
+ if (render_dotted) {
+ // alpha needs to be larger than in the line case to maintain a similar
+ // visual impact but setting it to the maximal value makes the dots
+ // dominant in some cases. Solution, increase the alpha by a factor of
+ // 4. This then allows some user adjustment.
+ guint32 _empdot = (_empcolor & 0xff) << 2;
+ if (_empdot > 0xff)
+ _empdot = 0xff;
+ _empdot += (_empcolor & 0xffffff00);
+
+ guint32 _colordot = (_color & 0xff) << 2;
+ if (_colordot > 0xff)
+ _colordot = 0xff;
+ _colordot += (_color & 0xffffff00);
+
+ // Dash pattern must use spacing from orthogonal direction.
+ // Offset is to center dash on orthogonal lines.
+ double offset = fmod( signed_distance( x[0], orth ), sw[dim].length());
+ if (Geom::cross( axis.vector(), orth.vector() ) > 0 ) {
+ offset = -offset;
+ }
+
+ std::vector<double> dashes;
+ if (!scaled[dim] && (j % empspacing) != 0) {
+ // Minor lines
+ dashes.push_back(1.0);
+ dashes.push_back(dash - 1.0);
+ offset -= 0.5;
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_colordot), SP_RGBA32_G_F(_colordot),
+ SP_RGBA32_B_F(_colordot), SP_RGBA32_A_F(_colordot));
+ } else {
+ // Major lines
+ dashes.push_back(3.0);
+ dashes.push_back(dash - 3.0);
+ offset -= 1.5; // Center dash on intersection.
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_empdot), SP_RGBA32_G_F(_empdot),
+ SP_RGBA32_B_F(_empdot), SP_RGBA32_A_F(_empdot));
+ }
+
+ buf->cr->set_line_cap(Cairo::LINE_CAP_BUTT);
+ buf->cr->set_dash(dashes, -offset);
+
+ } else {
+
+ // Solid lines
+
+ // Set color
+ if (!scaled[dim] && (j % empspacing) != 0) {
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_color), SP_RGBA32_G_F(_color),
+ SP_RGBA32_B_F(_color), SP_RGBA32_A_F(_color));
+ } else {
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_empcolor), SP_RGBA32_G_F(_empcolor),
+ SP_RGBA32_B_F(_empcolor), SP_RGBA32_A_F(_empcolor));
+ }
+ }
+
+ buf->cr->stroke();
+
+ } else {
+ std::cerr << "CanvasXYGrid::render: Grid line doesn't intersect!" << std::endl;
+ }
+ }
+ }
+
+ buf->cr->restore();
+}
+
+CanvasXYGridSnapper::CanvasXYGridSnapper(CanvasXYGrid *grid, SnapManager *sm, Geom::Coord const d) : LineSnapper(sm, d)
+{
+ this->grid = grid;
+}
+
+/**
+ * \return Snap tolerance (desktop coordinates); depends on current zoom so that it's always the same in screen pixels
+ */
+Geom::Coord CanvasXYGridSnapper::getSnapperTolerance() const
+{
+ SPDesktop const *dt = _snapmanager->getDesktop();
+ double const zoom = dt ? dt->current_zoom() : 1;
+ return _snapmanager->snapprefs.getGridTolerance() / zoom;
+}
+
+bool CanvasXYGridSnapper::getSnapperAlwaysSnap() const
+{
+ return _snapmanager->snapprefs.getGridTolerance() == 10000; //TODO: Replace this threshold of 10000 by a constant; see also tolerance-slider.cpp
+}
+
+LineSnapper::LineList
+CanvasXYGridSnapper::_getSnapLines(Geom::Point const &p) const
+{
+ LineList s;
+
+ if ( grid == nullptr ) {
+ return s;
+ }
+
+ for (unsigned int i = 0; i < 2; ++i) {
+
+ double spacing;
+
+ if (getSnapVisibleOnly()) {
+ // Only snapping to visible grid lines
+ spacing = grid->sw[i].length(); // this is the spacing of the visible grid lines measured in screen pixels
+ // convert screen pixels to px
+ // FIXME: after we switch to snapping dist in screen pixels, this will be unnecessary
+ SPDesktop const *dt = _snapmanager->getDesktop();
+ if (dt) {
+ spacing /= dt->current_zoom();
+ }
+ } else {
+ // Snapping to any grid line, whether it's visible or not
+ spacing = grid->spacing[i];
+ }
+
+ Geom::Coord rounded;
+ Geom::Point point_on_line;
+ Geom::Point cvec(0.,0.);
+ cvec[i] = 1.;
+
+ rounded = Inkscape::Util::round_to_upper_multiple_plus(p[i], spacing, grid->origin[i]);
+ point_on_line = i ? Geom::Point(0, rounded) : Geom::Point(rounded, 0);
+ s.push_back(std::make_pair(cvec, point_on_line));
+
+ rounded = Inkscape::Util::round_to_lower_multiple_plus(p[i], spacing, grid->origin[i]);
+ point_on_line = i ? Geom::Point(0, rounded) : Geom::Point(rounded, 0);
+ s.push_back(std::make_pair(cvec, point_on_line));
+ }
+
+ return s;
+}
+
+void CanvasXYGridSnapper::_addSnappedLine(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, Geom::Point const &normal_to_line, Geom::Point const &point_on_line) const
+{
+ SnappedLine dummy = SnappedLine(snapped_point, snapped_distance, source, source_num, Inkscape::SNAPTARGET_GRID, getSnapperTolerance(), getSnapperAlwaysSnap(), normal_to_line, point_on_line);
+ isr.grid_lines.push_back(dummy);
+}
+
+void CanvasXYGridSnapper::_addSnappedPoint(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, bool constrained_snap) const
+{
+ SnappedPoint dummy = SnappedPoint(snapped_point, source, source_num, Inkscape::SNAPTARGET_GRID, snapped_distance, getSnapperTolerance(), getSnapperAlwaysSnap(), constrained_snap, true);
+ isr.points.push_back(dummy);
+}
+
+void CanvasXYGridSnapper::_addSnappedLinePerpendicularly(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, bool constrained_snap) const
+{
+ SnappedPoint dummy = SnappedPoint(snapped_point, source, source_num, Inkscape::SNAPTARGET_GRID_PERPENDICULAR, snapped_distance, getSnapperTolerance(), getSnapperAlwaysSnap(), constrained_snap, true);
+ isr.points.push_back(dummy);
+}
+
+/**
+ * \return true if this Snapper will snap at least one kind of point.
+ */
+bool CanvasXYGridSnapper::ThisSnapperMightSnap() const
+{
+ return _snap_enabled && _snapmanager->snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_GRID);
+}
+
+} // namespace Inkscape
+
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-grid.h b/src/display/control/canvas-grid.h
new file mode 100644
index 0000000..860a106
--- /dev/null
+++ b/src/display/control/canvas-grid.h
@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * Cartesian grid item for the Inkscape canvas.
+ *//*
+ * Authors: see git history
+ *
+ * Copyright (C) 2018 Authors
+ * Copyright (C) Johan Engelen 2006-2007 <johan@shouraizou.nl>
+ * Copyright (C) Lauris Kaplinski 2000
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef INKSCAPE_CANVAS_GRID_H
+#define INKSCAPE_CANVAS_GRID_H
+
+#include "ui/widget/alignment-selector.h"
+#include "ui/widget/registered-widget.h"
+#include "ui/widget/registry.h"
+#include "line-snapper.h"
+
+class SPDesktop;
+class SPNamedView;
+class SPDocument;
+
+namespace Gtk {
+ class Widget;
+}
+
+namespace Inkscape {
+
+class Snapper;
+class CanvasItemBuffer;
+class CanvasItemGrid;
+
+namespace XML {
+class Node;
+}
+
+namespace Util {
+class Unit;
+}
+
+enum GridType {
+ GRID_RECTANGULAR = 0,
+ GRID_AXONOMETRIC = 1
+};
+
+#define GRID_MAXTYPENR 1
+
+#define GRID_DEFAULT_COLOR 0x0099e526
+#define GRID_DEFAULT_EMPCOLOR 0x0099e54d
+
+class CanvasGrid {
+public:
+ virtual ~CanvasGrid();
+
+ // TODO: see effect.h and effect.cpp from live_effects how to link enums to SVGname to typename properly. (johan)
+ const char * getName() const;
+ const char * getSVGName() const;
+ GridType getGridType() const;
+ static const char * getName(GridType type);
+ static const char * getSVGName(GridType type);
+ static GridType getGridTypeFromSVGName(const char * typestr);
+ static GridType getGridTypeFromName(const char * typestr);
+
+ static CanvasGrid* NewGrid(SPNamedView * nv, Inkscape::XML::Node * repr, SPDocument *doc, GridType gridtype);
+ static void writeNewGridToRepr(Inkscape::XML::Node * repr, SPDocument * doc, GridType gridtype);
+
+ Inkscape::CanvasItemGrid * createCanvasItem(SPDesktop * desktop);
+ void removeCanvasItem(Inkscape::CanvasItemGrid *item);
+
+ virtual void Update (Geom::Affine const &affine, unsigned int flags) = 0;
+ virtual void Render (Inkscape::CanvasItemBuffer *buf) = 0;
+
+ virtual void readRepr() = 0;
+ virtual void onReprAttrChanged (Inkscape::XML::Node * /*repr*/, char const */*key*/, char const */*oldval*/, char const */*newval*/, bool /*is_interactive*/) = 0;
+
+ Gtk::Widget * newWidget();
+ static void *notifyWidgetsDestroyed(void *data);
+
+ void setOrigin(Geom::Point const &origin_px); /**< writes new origin (specified in px units) to SVG */
+ Geom::Point origin; /**< Origin of the grid */
+
+ guint32 color; /**< Color for normal lines */
+ guint32 empcolor; /**< Color for emphasis lines */
+ gint empspacing; /**< Spacing between emphasis lines */
+
+ Inkscape::Util::Unit const* gridunit; /**< points to Unit object in UnitTable (so don't delete it) */
+
+ Inkscape::XML::Node * repr;
+ SPDocument *doc;
+
+ Inkscape::Snapper* snapper;
+
+ static void on_repr_attr_changed (Inkscape::XML::Node * repr, const gchar *key, const gchar *oldval, const gchar *newval, bool is_interactive, void * data);
+
+ bool isLegacy() const { return legacy; }
+ bool isPixel() const { return pixel; }
+
+ bool isVisible() const { return (isEnabled() &&visible); };
+ bool isEnabled() const;
+
+ void align_clicked(int align);
+
+protected:
+ CanvasGrid(SPNamedView * nv, Inkscape::XML::Node * in_repr, SPDocument *in_doc, GridType type);
+
+ virtual Gtk::Widget * newSpecificWidget() = 0;
+
+ std::vector<Inkscape::CanvasItemGrid *> canvas_item_grids; // List of created CanvasGridItem's.
+
+ SPNamedView * namedview;
+
+ Inkscape::UI::Widget::Registry _wr;
+ bool visible;
+ bool render_dotted;
+
+ GridType gridtype;
+
+ // For dealing with old Inkscape SVG files (pre 0.92)
+ bool legacy;
+ bool pixel;
+
+ Inkscape::UI::Widget::RegisteredCheckButton *_rcb_enabled = nullptr;
+ Inkscape::UI::Widget::RegisteredCheckButton *_rcb_snap_visible_only = nullptr;
+ Inkscape::UI::Widget::RegisteredCheckButton *_rcb_visible = nullptr;
+ Inkscape::UI::Widget::RegisteredCheckButton *_rcb_dotted = nullptr;
+ Inkscape::UI::Widget::AlignmentSelector *_as_alignment = nullptr;
+
+private:
+ CanvasGrid(const CanvasGrid&) = delete;
+ CanvasGrid& operator=(const CanvasGrid&) = delete;
+};
+
+
+class CanvasXYGrid : public CanvasGrid {
+public:
+ CanvasXYGrid(SPNamedView * nv, Inkscape::XML::Node * in_repr, SPDocument * in_doc);
+ ~CanvasXYGrid() override;
+
+ virtual void Scale (Geom::Scale const &scale);
+ void Update (Geom::Affine const &affine, unsigned int flags) override;
+ void Render (Inkscape::CanvasItemBuffer *buf) override;
+
+ void readRepr() override;
+ void onReprAttrChanged (Inkscape::XML::Node * repr, char const *key, char const *oldval, char const *newval, bool is_interactive) override;
+
+ Geom::Point spacing; /**< Spacing between elements of the grid */
+ bool scaled[2]; /**< Whether the grid is in scaled mode, which can
+ be different in the X or Y direction, hence two
+ variables */
+ Geom::Point ow; /**< Transformed origin by the affine for the zoom */
+ Geom::Point sw[2]; /**< Transformed spacing by the affine for the zoom */
+
+protected:
+ Gtk::Widget * newSpecificWidget() override;
+
+private:
+ CanvasXYGrid(const CanvasXYGrid&) = delete;
+ CanvasXYGrid& operator=(const CanvasXYGrid&) = delete;
+
+ void updateWidgets();
+
+ Inkscape::UI::Widget::RegisteredUnitMenu *_rumg = nullptr;
+ Inkscape::UI::Widget::RegisteredScalarUnit *_rsu_ox = nullptr;
+ Inkscape::UI::Widget::RegisteredScalarUnit *_rsu_oy = nullptr;
+ Inkscape::UI::Widget::RegisteredScalarUnit *_rsu_sx = nullptr;
+ Inkscape::UI::Widget::RegisteredScalarUnit *_rsu_sy = nullptr;
+ Inkscape::UI::Widget::RegisteredColorPicker *_rcp_gcol = nullptr;
+ Inkscape::UI::Widget::RegisteredColorPicker *_rcp_gmcol = nullptr;
+ Inkscape::UI::Widget::RegisteredSuffixedInteger *_rsi = nullptr;
+};
+
+
+
+class CanvasXYGridSnapper : public LineSnapper
+{
+public:
+ CanvasXYGridSnapper(CanvasXYGrid *grid, SnapManager *sm, Geom::Coord const d);
+ bool ThisSnapperMightSnap() const override;
+
+ Geom::Coord getSnapperTolerance() const override; //returns the tolerance of the snapper in screen pixels (i.e. independent of zoom)
+ bool getSnapperAlwaysSnap() const override; //if true, then the snapper will always snap, regardless of its tolerance
+
+private:
+ LineList _getSnapLines(Geom::Point const &p) const override;
+ void _addSnappedLine(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, Geom::Point const &normal_to_line, const Geom::Point &point_on_line) const override;
+ void _addSnappedPoint(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, bool constrained_snap) const override;
+ void _addSnappedLinePerpendicularly(IntermSnapResults &isr, Geom::Point const &snapped_point, Geom::Coord const &snapped_distance, SnapSourceType const &source, long source_num, bool constrained_snap) const override;
+ CanvasXYGrid *grid;
+};
+
+}; /* namespace Inkscape */
+
+
+
+
+#endif
diff --git a/src/display/control/canvas-item-bpath.cpp b/src/display/control/canvas-item-bpath.cpp
new file mode 100644
index 0000000..6938ac5
--- /dev/null
+++ b/src/display/control/canvas-item-bpath.cpp
@@ -0,0 +1,262 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to represent a Bezier path.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasBPath
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-item-bpath.h"
+
+#include <memory> // unique_ptr
+#include <utility> // std::move
+
+#include "color.h" // SP_RGBA_x_F
+
+#include "display/curve.h"
+#include "display/cairo-utils.h"
+
+#include "helper/geom.h" // bounds_exact_transformed()
+
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+/**
+ * Create an null control bpath.
+ */
+CanvasItemBpath::CanvasItemBpath(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemBpath:Null";
+ _pickable = true; // For now, nobody gets events from this class!
+}
+
+/**
+ * Create a control bpath. Curve is in document coordinates.
+ */
+CanvasItemBpath::CanvasItemBpath(CanvasItemGroup *group, SPCurve *curve, bool phantom_line)
+ : CanvasItem(group)
+ , _phantom_line(phantom_line)
+{
+ _name = "CanvasItemBpath";
+ _pickable = true; // For now, everyone gets events from this class!
+ if (curve) {
+ _path = curve->get_pathvector();
+ }
+
+ request_update(); // Render immediately or temporary bpaths won't show.
+}
+
+/**
+ * Create a control bpath. Path is in document coordinates.
+ */
+CanvasItemBpath::CanvasItemBpath(CanvasItemGroup *group, Geom::PathVector path, bool phantom_line)
+ : CanvasItem(group)
+ , _path(std::move(path))
+ , _phantom_line(phantom_line)
+{
+ _name = "CanvasItemBpath";
+ _pickable = true; // For now, everyone gets events from this class!
+ request_update(); // Render immediately or temporary bpaths won't show.
+}
+
+/**
+ * Set a control bpath. Curve is in document coordinates.
+ */
+void CanvasItemBpath::set_bpath(SPCurve *curve, bool phantom_line)
+{
+ if (curve) { // No test to see if *curve == *_curve so we always do the swap.
+ _path = curve->get_pathvector();
+ } else {
+ _path.clear();
+ }
+
+ _phantom_line = phantom_line;
+
+ request_update();
+}
+
+/**
+ * Set a control bpath. Path is in document coordinates.
+ */
+void CanvasItemBpath::set_bpath(Geom::PathVector const &path, bool phantom_line)
+{
+ _path = path;
+ _phantom_line = phantom_line;
+
+ request_update();
+}
+
+/**
+ * Set the fill color and fill rule.
+ */
+void CanvasItemBpath::set_fill(guint rgba, SPWindRule fill_rule)
+{
+ if (_fill != rgba || _fill_rule != fill_rule) {
+ _fill = rgba;
+ _fill_rule = fill_rule;
+ request_redraw();
+ }
+}
+
+/**
+ * Returns distance between point in canvas units and nearest point on bpath.
+ */
+double CanvasItemBpath::closest_distance_to(Geom::Point const &p)
+{
+ double d = Geom::infinity();
+
+ // Convert p to document coordinates (quicker than converting path to canvas units).
+ Geom::Point p_doc = p * _affine.inverse();
+ _path.nearestTime(p_doc, &d);
+ d *= _affine.descrim(); // Uniform scaling and rotation only.
+
+ return d;
+}
+
+/**
+ * Returns true if point p (in canvas units) is within tolerance (canvas units) distance of bpath.
+ */
+bool CanvasItemBpath::contains(Geom::Point const &p, double tolerance)
+{
+ if (tolerance == 0) {
+ tolerance = 1; // Need a minimum tolerance value or always returns false.
+ }
+
+ return closest_distance_to(p) < tolerance;
+}
+
+/**
+ * Update and redraw control bpath.
+ */
+void CanvasItemBpath::update(Geom::Affine const &affine)
+{
+ if (_affine == affine && !_need_update) {
+ // Nothing to do.
+ return;
+ }
+
+ // Queue redraw of old area (erase previous content).
+ request_redraw();
+
+ // Get new bounds
+ _affine = affine;
+
+ _bounds = Geom::Rect(); // Reset bounds
+
+ if (_path.empty()) return; // No path, no chocolate!
+
+ Geom::OptRect bbox = bounds_exact_transformed(_path, _affine);
+
+ if (bbox) {
+ _bounds = *bbox;
+ _bounds.expandBy(2);
+ } else {
+ _bounds = Geom::Rect();
+ }
+
+ // Queue redraw of new area
+ request_redraw();
+
+ _need_update = false;
+}
+
+/**
+ * Render bpath to screen via Cairo.
+ */
+void CanvasItemBpath::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (!buf) {
+ std::cerr << "CanvasItemBpath::Render: No buffer!" << std::endl;
+ return;
+ }
+
+ if (!_visible) {
+ // Hidden
+ return;
+ }
+
+ if (_path.empty()) {
+ return;
+ }
+
+ bool do_fill = (_fill & 0xff) != 0; // Not invisible.
+ bool do_stroke = (_stroke & 0xff) != 0; // Not invisible.
+
+ if (!do_fill && !do_stroke) {
+ // Both fill and stroke invisible.
+ return;
+ }
+
+ buf->cr->save();
+
+ // Setup path
+ buf->cr->set_tolerance(0.5);
+ buf->cr->begin_new_path();
+
+ feed_pathvector_to_cairo (buf->cr->cobj(), _path, _affine, buf->rect,
+ /* optimized_stroke = */ !do_fill, 1);
+
+ // Do fill
+ if (do_fill) {
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_fill), SP_RGBA32_G_F(_fill),
+ SP_RGBA32_B_F(_fill), SP_RGBA32_A_F(_fill));
+ buf->cr->set_fill_rule(_fill_rule == SP_WIND_RULE_EVENODD ?
+ Cairo::FILL_RULE_EVEN_ODD : Cairo::FILL_RULE_WINDING);
+ buf->cr->fill_preserve();
+ }
+
+ // Do stroke
+ if (do_stroke) {
+
+ if (!_dashes.empty()) {
+ buf->cr->set_dash(_dashes, 0.0); // 0.0 is offset
+ }
+
+ if (_phantom_line) {
+ buf->cr->set_source_rgba(1.0, 1.0, 1.0, 0.25);
+ buf->cr->set_line_width(2.0);
+ buf->cr->stroke_preserve();
+ }
+
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_stroke), SP_RGBA32_G_F(_stroke),
+ SP_RGBA32_B_F(_stroke), SP_RGBA32_A_F(_stroke));
+ buf->cr->set_line_width(1.0);
+ buf->cr->stroke();
+
+ } else {
+ buf->cr->begin_new_path(); // Clears path
+ }
+
+ // Uncomment to show bounds
+ // Geom::Rect bounds = _bounds;
+ // bounds.expandBy(-1);
+ // bounds -= buf->rect.min();
+ // buf->cr->set_source_rgba(1.0, 0.0, 0.0, 1.0);
+ // buf->cr->rectangle(bounds.min().x(), bounds.min().y(), bounds.width(), bounds.height());
+ // buf->cr->stroke();
+
+ buf->cr->restore();
+}
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-bpath.h b/src/display/control/canvas-item-bpath.h
new file mode 100644
index 0000000..e430cc1
--- /dev/null
+++ b/src/display/control/canvas-item-bpath.h
@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_BPATH_H
+#define SEEN_CANVAS_ITEM_BPATH_H
+
+/**
+ * A class to represent a Bezier path.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasBPath
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <2geom/transforms.h>
+#include <2geom/pathvector.h>
+
+#include "canvas-item.h"
+
+#include "style-enums.h" // Fill rule
+
+class SPCurve;
+
+namespace Inkscape {
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemBpath : public CanvasItem {
+
+public:
+ CanvasItemBpath(CanvasItemGroup *group);
+ CanvasItemBpath(CanvasItemGroup *group, SPCurve *curve, bool phantom_line = false);
+ CanvasItemBpath(CanvasItemGroup *group, Geom::PathVector path, bool phantom_line = false);
+
+ // Geometry
+ void set_bpath (SPCurve *curve, bool phantom_line = false);
+ void set_bpath (Geom::PathVector const &path, bool phantom_line = false);
+ void set_affine_absolute(Geom::Affine const &affine);
+
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p); // Maybe not needed
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+ // Properties
+ void set_fill (guint32 rgba, SPWindRule fill_rule);
+ void set_dashes (std::vector<double> & dashes) { _dashes = dashes; }
+
+protected:
+
+ // Geometry
+ Geom::PathVector _path;
+
+ // Properties
+ SPWindRule _fill_rule = SP_WIND_RULE_EVENODD;
+ std::vector<double> _dashes;
+ bool _phantom_line = false;
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_BPATH_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 :
diff --git a/src/display/control/canvas-item-buffer.h b/src/display/control/canvas-item-buffer.h
new file mode 100644
index 0000000..3f829b0
--- /dev/null
+++ b/src/display/control/canvas-item-buffer.h
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_BUFFER_H
+#define SEEN_CANVAS_ITEM_BUFFER_H
+
+/**
+ * Buffer for rendering canvas items.
+ */
+
+/*
+ * Author:
+ * See git history.
+ *
+ * Copyright (C) 2020 Authors
+ *
+ * Rewrite of SPCanvasBuf.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ *
+ */
+
+#include <2geom/rect.h>
+#include <cairomm/context.h>
+#include "display/rendermode.h"
+
+namespace Inkscape {
+
+/**
+ * Class used when rendering canvas items.
+ */
+struct CanvasItemBuffer {
+ Geom::IntRect rect;
+ int device_scale; // For high DPI monitors.
+ bool outline_overlay_pass; // Hack for not painting page colour in outline overlay mode
+ Cairo::RefPtr<Cairo::Context> cr;
+};
+
+} // Namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_BUFFER_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 :
diff --git a/src/display/control/canvas-item-catchall.cpp b/src/display/control/canvas-item-catchall.cpp
new file mode 100644
index 0000000..91bd323
--- /dev/null
+++ b/src/display/control/canvas-item-catchall.cpp
@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to catch events after everyone else has had a go.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasAcetate.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-item-catchall.h"
+
+#include "color.h" // SP_RGBA_x_F
+
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+/**
+ * Create an null control catchall.
+ */
+CanvasItemCatchall::CanvasItemCatchall(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemCatchall";
+ _pickable = true; // Duh! That's the purpose of this class!
+ _bounds = Geom::Rect(-Geom::infinity(), -Geom::infinity(), Geom::infinity(), Geom::infinity());
+}
+
+/**
+ * Returns distance between point in canvas units and nearest point on catchall.
+ */
+double CanvasItemCatchall::closest_distance_to(Geom::Point const &p)
+{
+ return 0.0; // We're everywhere!
+}
+
+/**
+ * Returns true if point p (in canvas units) is within tolerance (canvas units) distance of catchall.
+ */
+bool CanvasItemCatchall::contains(Geom::Point const &p, double tolerance)
+{
+ return true; // We contain every place!
+}
+
+/**
+ * Update and redraw control catchall.
+ */
+void CanvasItemCatchall::update(Geom::Affine const &affine)
+{
+ // No geometry to update.
+ _affine = affine;
+}
+
+/**
+ * Render catchall to screen via Cairo.
+ */
+void CanvasItemCatchall::render(Inkscape::CanvasItemBuffer *buf)
+{
+ // Do nothing! (Needed as CanvasItem is abstract.)
+}
+
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-catchall.h b/src/display/control/canvas-item-catchall.h
new file mode 100644
index 0000000..d40ab45
--- /dev/null
+++ b/src/display/control/canvas-item-catchall.h
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_CATCHALL_H
+#define SEEN_CANVAS_ITEM_CATCHALL_H
+
+/**
+ * A class to catch events after everyone else has had a go.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasAcetate.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <2geom/point.h>
+#include <2geom/transforms.h>
+
+#include "canvas-item.h"
+
+namespace Inkscape {
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemCatchall : public CanvasItem {
+
+public:
+ CanvasItemCatchall(CanvasItemGroup *group);
+
+ // Geometry
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p);
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_CATCHALL_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 :
diff --git a/src/display/control/canvas-item-ctrl.cpp b/src/display/control/canvas-item-ctrl.cpp
new file mode 100644
index 0000000..f2696c8
--- /dev/null
+++ b/src/display/control/canvas-item-ctrl.cpp
@@ -0,0 +1,1221 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to represent a control node.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCtrl
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <2geom/transforms.h>
+
+#include "canvas-item-ctrl.h"
+
+#include "preferences.h" // Default size.
+#include "display/cairo-utils.h" // argb32_from_rgba()
+
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+CanvasItemCtrl::~CanvasItemCtrl()
+{
+ delete[] _cache;
+}
+
+/**
+ * Create an null control node.
+ */
+CanvasItemCtrl::CanvasItemCtrl(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemCtrl:Null";
+ _pickable = true; // Everybody gets events from this class!
+}
+
+/**
+ * Create a control ctrl. Shape auto-set by type.
+ */
+CanvasItemCtrl::CanvasItemCtrl(CanvasItemGroup *group, Inkscape::CanvasItemCtrlType type)
+ : CanvasItem(group)
+ , _type(type)
+{
+ _name = "CanvasItemCtrl:Type_" + std::to_string(_type);
+ _pickable = true; // Everybody gets events from this class!
+
+ // Use _type to set default values:
+ set_shape_default();
+ set_size_default();
+}
+
+/**
+ * Create a control ctrl. Point is in document coordinates.
+ */
+CanvasItemCtrl::CanvasItemCtrl(CanvasItemGroup *group, Inkscape::CanvasItemCtrlType type, Geom::Point const &p)
+ : CanvasItemCtrl(group, type)
+{
+ _position = p;
+}
+
+
+/**
+ * Create a control ctrl.
+ */
+CanvasItemCtrl::CanvasItemCtrl(CanvasItemGroup *group, Inkscape::CanvasItemCtrlShape shape)
+ : CanvasItem(group)
+ , _shape(shape)
+ , _type(CANVAS_ITEM_CTRL_TYPE_DEFAULT)
+{
+ _name = "CanvasItemCtrl:Shape_" + std::to_string(_shape);
+ _pickable = true; // Everybody gets events from this class!
+}
+
+
+/**
+ * Create a control ctrl. Point is in document coordinates.
+ */
+CanvasItemCtrl::CanvasItemCtrl(CanvasItemGroup *group, Inkscape::CanvasItemCtrlShape shape, Geom::Point const &p)
+ : CanvasItemCtrl(group, shape)
+{
+ _position = p;
+ request_update();
+}
+
+/**
+ * Set the position. Point is in document coordinates.
+ */
+void CanvasItemCtrl::set_position(Geom::Point const &position)
+{
+ // std::cout << "CanvasItemCtrl::set_ctrl: " << _name << ": " << position << std::endl;
+ if (_position != position) {
+ _position = position;
+ request_update();
+ }
+}
+
+/**
+ * Returns distance between point in canvas units and position of ctrl.
+ */
+double CanvasItemCtrl::closest_distance_to(Geom::Point const &p)
+{
+ // TODO: Different criteria for different shapes.
+ Geom::Point position = _position * _affine;
+ return Geom::distance(p, position);
+}
+
+/**
+ * If tolerance is zero, returns true if point p (in canvas units) is inside bounding box,
+ * else returns true if p (in canvas units) is within tolerance (canvas units) distance of ctrl.
+ * The latter assumes ctrl center anchored.
+ */
+bool CanvasItemCtrl::contains(Geom::Point const &p, double tolerance)
+{
+ // TODO: Different criteria for different shapes.
+ if (tolerance == 0) {
+ return _bounds.interiorContains(p);
+ } else {
+ return closest_distance_to(p) <= tolerance;
+ }
+}
+
+/**
+ * Update and redraw control ctrl.
+ */
+void CanvasItemCtrl::update(Geom::Affine const &affine)
+{
+ if (_affine == affine && !_need_update) {
+ // Nothing to do.
+ return;
+ }
+
+ // Queue redraw of old area (erase previous content).
+ request_redraw();
+
+ // Get new bounds
+ _affine = affine;
+
+ // We must be pixel aligned, width and height are always odd.
+ _bounds = Geom::Rect::from_xywh(-(_width/2.0 - 0.5), -(_height/2.0 - 0.5), _width, _height);
+
+ // Adjust for anchor
+ int w_half = _width/2;
+ int h_half = _height/2;
+ int dx = 0;
+ int dy = 0;
+
+ switch (_shape) {
+ case CANVAS_ITEM_CTRL_SHAPE_DARROW:
+ case CANVAS_ITEM_CTRL_SHAPE_SARROW:
+ case CANVAS_ITEM_CTRL_SHAPE_CARROW:
+ case CANVAS_ITEM_CTRL_SHAPE_SALIGN:
+ case CANVAS_ITEM_CTRL_SHAPE_CALIGN:
+ {
+
+ _angle = _anchor * M_PI/4.0 + std::atan2(_affine[1], _affine[0]);
+
+ double half = _width/2.0;
+
+ dx = - (half + 2) * cos(_angle); // Add a bit to prevent tip from overlapping due to rounding errors.
+ dy = - (half + 2) * sin(_angle);
+
+ switch (_shape) {
+
+ case CANVAS_ITEM_CTRL_SHAPE_CARROW:
+ _angle += 5 * M_PI/4.0;
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_SARROW:
+ _angle += M_PI/2.0;
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_SALIGN:
+ dx = - (half/2 + 2) * cos(_angle);
+ dy = - (half/2 + 2) * sin(_angle);
+ _angle -= M_PI/2.0;
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_CALIGN:
+ _angle -= M_PI/4.0;
+ dx = (half/2 + 2) * ( sin(_angle) - cos(_angle));
+ dy = (half/2 + 2) * (-sin(_angle) - cos(_angle));
+ break;
+
+ default:
+ break;
+ }
+
+ _built = false; // Angle may have change, must rebuild!
+
+ break;
+ }
+
+ case CANVAS_ITEM_CTRL_SHAPE_PIVOT:
+ case CANVAS_ITEM_CTRL_SHAPE_MALIGN:
+
+ _angle = std::atan2(_affine[1], _affine[0]);
+
+ _built = false; // Angle may have change, must rebuild!
+
+ break;
+
+ default:
+
+ switch (_anchor) {
+ case SP_ANCHOR_N:
+ case SP_ANCHOR_CENTER:
+ case SP_ANCHOR_S:
+ break;
+
+ case SP_ANCHOR_NW:
+ case SP_ANCHOR_W:
+ case SP_ANCHOR_SW:
+ dx = w_half;
+ break;
+
+ case SP_ANCHOR_NE:
+ case SP_ANCHOR_E:
+ case SP_ANCHOR_SE:
+ dx = -w_half;
+ break;
+ }
+
+ switch (_anchor) {
+ case SP_ANCHOR_W:
+ case SP_ANCHOR_CENTER:
+ case SP_ANCHOR_E:
+ break;
+
+ case SP_ANCHOR_NW:
+ case SP_ANCHOR_N:
+ case SP_ANCHOR_NE:
+ dy = h_half;
+ break;
+
+ case SP_ANCHOR_SW:
+ case SP_ANCHOR_S:
+ case SP_ANCHOR_SE:
+ dy = -h_half;
+ break;
+ }
+ break;
+ }
+
+ _bounds *= Geom::Translate(Geom::IntPoint(dx, dy));
+
+ // Position must also be integer.
+ Geom::Point position = _position * _affine;
+ Geom::IntPoint iposition = position.floor();
+
+ _bounds *= Geom::Translate(iposition);
+
+ // Queue redraw of new area
+ request_redraw();
+
+ _need_update = false;
+}
+
+
+static inline guint32 compose_xor(guint32 bg, guint32 fg, guint32 a)
+{
+ guint32 c = bg * (255-a) + (((bg ^ ~fg) + (bg >> 2) - (bg > 127 ? 63 : 0)) & 255) * a;
+ return (c + 127) / 255;
+}
+
+/**
+ * Render ctrl to screen via Cairo.
+ */
+void CanvasItemCtrl::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (!buf) {
+ std::cerr << "CanvasItemCtrl::Render: No buffer!" << std::endl;
+ return;
+ }
+
+ if (!_bounds.intersects(buf->rect)) {
+ return; // Control not inside buffer rectangle.
+ }
+
+ if (!_visible) {
+ return; // Hidden.
+ }
+
+ if (!_built) {
+ build_cache(buf->device_scale);
+ }
+
+ Geom::Point c = _bounds.min() - buf->rect.min();
+ int x = c.x(); // Must be pixel aligned.
+ int y = c.y();
+
+ buf->cr->save();
+
+ // This code works regardless of source type.
+
+ // 1. Copy the affected part of output to a temporary surface
+
+ // Size in device pixels. Does not set device scale.
+ int width = _width * buf->device_scale;
+ int height = _height * buf->device_scale;
+ auto work = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, width, height);
+ cairo_surface_set_device_scale(work->cobj(), buf->device_scale, buf->device_scale); // No C++ API!
+
+ auto cr = Cairo::Context::create(work);
+ cr->translate(-_bounds.left(), -_bounds.top());
+ cr->set_source(buf->cr->get_target(), buf->rect.left(), buf->rect.top());
+ cr->paint();
+ // static int a = 0;
+ // std::string name0 = "ctrl0_" + _name + "_" + std::to_string(a++) + ".png";
+ // work->write_to_png(name0);
+
+ // 2. Composite the control on a temporary surface
+ work->flush();
+ int strideb = work->get_stride();
+ unsigned char *pxb = work->get_data();
+
+ // this code allow background become isolated from rendering so we can do things like outline overlay
+ cairo_pattern_t *pattern = _canvas->get_background_pattern()->cobj();
+ guint32 backcolor = ink_cairo_pattern_get_argb32(pattern);
+ guint32 *p = _cache;
+ for (int i = 0; i < height; ++i) {
+ guint32 *pb = reinterpret_cast<guint32*>(pxb + i*strideb);
+ for (int j = 0; j < width; ++j) {
+ guint32 base = *pb;
+ guint32 cc = *p++;
+ guint32 ac = cc & 0xff;
+ if (*pb == 0 && cc != 0) {
+ base = backcolor;
+ }
+ if (ac == 0 && cc != 0) {
+ *pb++ = argb32_from_rgba(cc | 0x000000ff);
+ } else if (ac == 0) {
+ *pb++ = base;
+ } else if (
+ _mode == CANVAS_ITEM_CTRL_MODE_XOR ||
+ _mode == CANVAS_ITEM_CTRL_MODE_GRAYSCALED_XOR ||
+ _mode == CANVAS_ITEM_CTRL_MODE_DESATURATED_XOR)
+ {
+ EXTRACT_ARGB32(base, ab,rb,gb,bb)
+ // here we get canvas color and if color to draw
+ // has opacity, we override base colors
+ // flattenig canvas color
+ EXTRACT_ARGB32(backcolor, abb,rbb,gbb,bbb)
+ if (abb != ab) {
+ rb = (ab/255.0) * rb + (1-(ab/255.0)) * rbb;
+ gb = (ab/255.0) * gb + (1-(ab/255.0)) * gbb;
+ bb = (ab/255.0) * bb + (1-(ab/255.0)) * bbb;
+ ab = 255;
+ }
+ guint32 ro = compose_xor(rb, (cc & 0xff000000) >> 24, ac);
+ guint32 go = compose_xor(gb, (cc & 0x00ff0000) >> 16, ac);
+ guint32 bo = compose_xor(bb, (cc & 0x0000ff00) >> 8, ac);
+ if (_mode == CANVAS_ITEM_CTRL_MODE_GRAYSCALED_XOR ||
+ _mode == CANVAS_ITEM_CTRL_MODE_DESATURATED_XOR) {
+ guint32 gray = ro * 0.299 + go * 0.587 + bo * 0.114;
+ if (_mode == CANVAS_ITEM_CTRL_MODE_DESATURATED_XOR) {
+ double f = 0.85; // desaturate by 15%
+ double p = sqrt(ro * ro * 0.299 + go * go * 0.587 + bo * bo * 0.114);
+ ro = p + (ro - p) * f;
+ go = p + (go - p) * f;
+ bo = p + (bo - p) * f;
+ } else {
+ ro = gray;
+ go = gray;
+ bo = gray;
+ }
+ }
+ ASSEMBLE_ARGB32(px, ab,ro,go,bo)
+ *pb++ = px;
+ } else {
+ *pb++ = argb32_from_rgba(cc | 0x000000ff);
+ }
+ }
+ }
+ work->mark_dirty();
+ // std::string name1 = "ctrl1_" + _name + "_" + std::to_string(a) + ".png";
+ // work->write_to_png(name1);
+
+ // 3. Replace the affected part of output with contents of temporary surface
+ buf->cr->set_source(work, x, y);
+
+
+
+ buf->cr->rectangle(x, y, _width, _height);
+ buf->cr->clip();
+ buf->cr->set_operator(Cairo::OPERATOR_SOURCE);
+ buf->cr->paint();
+ buf->cr->restore();
+}
+
+void CanvasItemCtrl::set_fill(guint32 rgba)
+{
+ if (_fill != rgba) {
+ _fill = rgba;
+ _built = false;
+ request_redraw();
+ }
+}
+
+void CanvasItemCtrl::set_stroke(guint32 rgba)
+{
+ if (_stroke != rgba) {
+ _stroke = rgba;
+ _built = false;
+ request_redraw();
+ }
+}
+
+void CanvasItemCtrl::set_shape(int shape)
+{
+ if (_shape != shape) {
+ _shape = Inkscape::CanvasItemCtrlShape(shape); // Fixme
+ _built = false;
+ request_update(); // Geometry could change
+ }
+}
+
+void CanvasItemCtrl::set_shape_default()
+{
+ switch (_type) {
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_HANDLE:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_DARROW;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_SKEW:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_SARROW;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_ROTATE:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_CARROW;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_CENTER:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_PIVOT;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_SALIGN:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_SALIGN;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_CALIGN:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_CALIGN;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_MALIGN:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_MALIGN;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_NODE_AUTO:
+ case CANVAS_ITEM_CTRL_TYPE_ROTATE:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_CIRCLE;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_CENTER:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_PLUS;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_SHAPER:
+ case CANVAS_ITEM_CTRL_TYPE_LPE:
+ case CANVAS_ITEM_CTRL_TYPE_NODE_CUSP:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_DIAMOND;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_POINT:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_CROSS;
+ break;
+
+ default:
+ _shape = CANVAS_ITEM_CTRL_SHAPE_SQUARE;
+ }
+}
+
+void CanvasItemCtrl::set_mode(int mode)
+{
+ if (_mode != mode) {
+ _mode = Inkscape::CanvasItemCtrlMode(mode); // Fixme
+ _built = false;
+ request_update();
+ }
+}
+
+void CanvasItemCtrl::set_pixbuf(GdkPixbuf *pixbuf)
+{
+ if (_pixbuf != pixbuf) {
+ _pixbuf = pixbuf;
+ _width = gdk_pixbuf_get_width(pixbuf);
+ _height = gdk_pixbuf_get_height(pixbuf);
+ _built = false;
+ request_update();
+ }
+}
+
+// Nominally width == height == size except possibly for pixmaps.
+void CanvasItemCtrl::set_size(int size)
+{
+ if (_pixbuf) {
+ // std::cerr << "CanvasItemCtrl::set_size: Attempting to set size on pixbuf control!" << std::endl;
+ return;
+ }
+ if (_width != size + _extra || _height != size + _extra) {
+ _width = size + _extra;
+ _height = size + _extra;
+ _built = false;
+ request_update(); // Geometry change
+ }
+}
+
+void CanvasItemCtrl::set_size_via_index(int size_index)
+{
+ // Size must always be an odd number to center on pixel.
+
+ if (size_index < 1 || size_index > 15) {
+ std::cerr << "CanvasItemCtrl::set_size_via_index: size_index out of range!" << std::endl;
+ size_index = 3;
+ }
+
+ int size = 0;
+ switch (_type) {
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_HANDLE:
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_SKEW:
+ size = size_index * 2 + 7;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_ROTATE:
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_CENTER:
+ size = size_index * 2 + 9; // 2 larger than HANDLE/SKEW
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_SALIGN:
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_CALIGN:
+ case CANVAS_ITEM_CTRL_TYPE_ADJ_MALIGN:
+ size = size_index * 4 + 5; // Needs to be larger to allow for rotating.
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_POINT:
+ case CANVAS_ITEM_CTRL_TYPE_ROTATE:
+ case CANVAS_ITEM_CTRL_TYPE_CENTER:
+ case CANVAS_ITEM_CTRL_TYPE_SIZER:
+ case CANVAS_ITEM_CTRL_TYPE_SHAPER:
+ case CANVAS_ITEM_CTRL_TYPE_LPE:
+ case CANVAS_ITEM_CTRL_TYPE_NODE_AUTO:
+ case CANVAS_ITEM_CTRL_TYPE_NODE_CUSP:
+ size = size_index * 2 + 5;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_NODE_SMOOTH:
+ case CANVAS_ITEM_CTRL_TYPE_NODE_SYMETRICAL:
+ size = size_index * 2 + 3;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_INVISIPOINT:
+ size = 1;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_ANCHOR: // vanishing point for 3D box and anchor for pencil
+ size = size_index * 2 + 1;
+ break;
+
+ case CANVAS_ITEM_CTRL_TYPE_DEFAULT:
+ size = size_index * 2 + 1;
+ break;
+
+ default:
+ g_warning("set_size_via_index: missing case for handle type: %d", static_cast<int>(_type));
+ size = size_index * 2 + 1;
+ break;
+ }
+
+ set_size(size);
+}
+
+void CanvasItemCtrl::set_size_default()
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ int size = prefs->getIntLimited("/options/grabsize/value", 3, 1, 15);
+ set_size_via_index(size);
+}
+
+void CanvasItemCtrl::set_size_extra(int extra)
+{
+ if (_extra != extra && _pixbuf == nullptr) { // Don't enlarge pixbuf!
+ _width += (extra - _extra);
+ _height += (extra - _extra);
+ _extra = extra;
+ _built = false;
+ request_update(); // Geometry change
+ }
+}
+
+void CanvasItemCtrl::set_type(Inkscape::CanvasItemCtrlType type)
+{
+ if (_type != type) {
+ _type = type;
+
+ // Use _type to set default values:
+ set_shape_default();
+ set_size_default();
+ _built = false;
+ request_update(); // Possible Geometry change
+ }
+}
+
+void CanvasItemCtrl::set_angle(double angle)
+{
+ if (_angle != angle) {
+ _angle = angle;
+ request_update(); // Geometry change
+ }
+}
+
+void CanvasItemCtrl::set_anchor(SPAnchorType anchor)
+{
+ if (_anchor != anchor) {
+ _anchor = anchor;
+ request_update(); // Geometry change
+ }
+}
+
+// ---------- Protected ----------
+
+// Helper function for build_cache():
+bool point_inside_triangle(Geom::Point p1,Geom::Point p2,Geom::Point p3, Geom::Point point){
+ using Geom::X;
+ using Geom::Y;
+ double denominator = (p1[X]*(p2[Y] - p3[Y]) + p1[Y]*(p3[X] - p2[X]) + p2[X]*p3[Y] - p2[Y]*p3[X]);
+ double t1 = (point[X]*(p3[Y] - p1[Y]) + point[Y]*(p1[X] - p3[X]) - p1[X]*p3[Y] + p1[Y]*p3[X]) / denominator;
+ double t2 = (point[X]*(p2[Y] - p1[Y]) + point[Y]*(p1[X] - p2[X]) - p1[X]*p2[Y] + p1[Y]*p2[X]) / -denominator;
+ double see = t1 + t2;
+ return 0 <= t1 && t1 <= 1 && 0 <= t2 && t2 <= 1 && see <= 1;
+}
+
+
+void draw_darrow(Cairo::RefPtr<Cairo::Context>cr, double size) {
+
+ // Find points, starting from tip of one arrowhead, working clockwise.
+ /* 1 4
+ ╱│ │╲
+ ╱ └────────┘ ╲
+ 0╱ 2 3 ╲5
+ ╲ 8 7 ╱
+ ╲ ┌────────┐ ╱
+ ╲│9 6│╱
+ */
+
+ // Length of arrowhead (not including stroke).
+ double delta = (size-1)/4.0; // Use unscaled width.
+
+ // Tip of arrow (0)
+ double tip_x = 0.5; // At edge, allow room for stroke.
+ double tip_y = size/2.0; // Center, assuming width == height.
+
+ // Outer corner (1)
+ double out_x = tip_x + delta;
+ double out_y = tip_y - delta;
+
+ // Inner corner (2)
+ double in_x = out_x;
+ double in_y = out_y + (delta/2.0);
+
+ double x0 = tip_x; double y0 = tip_y;
+ double x1 = out_x; double y1 = out_y;
+ double x2 = in_x; double y2 = in_y;
+ double x3 = size - in_x; double y3 = in_y;
+ double x4 = size - out_x; double y4 = out_y;
+ double x5 = size - tip_x; double y5 = tip_y;
+ double x6 = size - out_x; double y6 = size - out_y;
+ double x7 = size - in_x; double y7 = size - in_y;
+ double x8 = in_x; double y8 = size - in_y;
+ double x9 = out_x; double y9 = size - out_y;
+
+ // Draw arrow
+ cr->move_to(x0, y0);
+ cr->line_to(x1, y1);
+ cr->line_to(x2, y2);
+ cr->line_to(x3, y3);
+ cr->line_to(x4, y4);
+ cr->line_to(x5, y5);
+ cr->line_to(x6, y6);
+ cr->line_to(x7, y7);
+ cr->line_to(x8, y8);
+ cr->line_to(x9, y9);
+ cr->close_path();
+}
+
+void draw_carrow(Cairo::RefPtr<Cairo::Context>cr, double size) {
+
+ // Length of arrowhead (not including stroke).
+ double delta = (size-3)/4.0; // Use unscaled width.
+
+ // Tip of arrow
+ double tip_x = 1.5; // Edge, allow room for stroke when rotated.
+ double tip_y = delta + 1.5;
+
+ // Outer corner (1)
+ double out_x = tip_x + delta;
+ double out_y = tip_y - delta;
+
+ // Inner corner (2)
+ double in_x = out_x;
+ double in_y = out_y + (delta/2.0);
+
+ double x0 = tip_x; double y0 = tip_y;
+ double x1 = out_x; double y1 = out_y;
+ double x2 = in_x; double y2 = in_y;
+ double x3 = size - in_y; //double y3 = size - in_x;
+ double x4 = size - out_y; double y4 = size - out_x;
+ double x5 = size - tip_y; double y5 = size - tip_x;
+ double x6 = x5 - delta; double y6 = y4;
+ double x7 = x5 - delta/2.0; double y7 = y4;
+ double x8 = x1; //double y8 = y0 + delta/2.0;
+ double x9 = x1; double y9 = y0 + delta;
+
+ // Draw arrow
+ cr->move_to(x0, y0);
+ cr->line_to(x1, y1);
+ cr->line_to(x2, y2);
+ cr->arc(x1, y4, x3-x2, 3.0*M_PI/2.0, 0);
+ cr->line_to(x4, y4);
+ cr->line_to(x5, y5);
+ cr->line_to(x6, y6);
+ cr->line_to(x7, y7);
+ cr->arc_negative(x1, y4, x7-x8, 0, 3.0*M_PI/2.0);
+ cr->line_to(x9, y9);
+ cr->close_path();
+}
+
+void draw_pivot(Cairo::RefPtr<Cairo::Context>cr, double size) {
+
+ double delta4 = (size-5)/4.0; // Keep away from edge or will clip when rotating.
+ double delta8 = delta4/2;
+
+ // Line start
+ double center = size/2.0;
+
+ cr->move_to (center - delta8, center - 2*delta4 - delta8);
+ cr->rel_line_to ( delta4, 0 );
+ cr->rel_line_to ( 0, delta4);
+
+ cr->rel_line_to ( delta4, delta4);
+
+ cr->rel_line_to ( delta4, 0 );
+ cr->rel_line_to ( 0, delta4);
+ cr->rel_line_to (-delta4, 0 );
+
+ cr->rel_line_to (-delta4, delta4);
+
+ cr->rel_line_to ( 0, delta4);
+ cr->rel_line_to (-delta4, 0 );
+ cr->rel_line_to ( 0, -delta4);
+
+ cr->rel_line_to (-delta4, -delta4);
+
+ cr->rel_line_to (-delta4, 0 );
+ cr->rel_line_to ( 0, -delta4);
+ cr->rel_line_to ( delta4, 0 );
+
+ cr->rel_line_to ( delta4, -delta4);
+ cr->close_path();
+
+ cr->begin_new_sub_path();
+ cr->arc_negative(center, center, delta4, 0, -2 * M_PI);
+}
+
+void draw_salign(Cairo::RefPtr<Cairo::Context>cr, double size) {
+
+ // Triangle pointing at line.
+
+ // Basic units.
+ double delta4 = (size-1)/4.0; // Use unscaled width.
+ double delta8 = delta4/2;
+ if (delta8 < 2) {
+ // Keep a minimum gap of at least one pixel (after stroking).
+ delta8 = 2;
+ }
+
+ // Tip of triangle
+ double tip_x = size/2.0; // Center (also rotation point).
+ double tip_y = size/2.0;
+
+ // Corner triangle position.
+ double outer = size/2.0 - delta4;
+
+ // Outer line position
+ double oline = size/2.0 + (int)delta4;
+
+ // Inner line position
+ double iline = size/2.0 + (int)delta8;
+
+ // Draw triangle
+ cr->move_to(tip_x, tip_y);
+ cr->line_to(outer, outer);
+ cr->line_to(size - outer, outer);
+ cr->close_path();
+
+ // Draw line
+ cr->move_to(outer, iline);
+ cr->line_to(size - outer, iline);
+ cr->line_to(size - outer, oline);
+ cr->line_to(outer, oline);
+ cr->close_path();
+}
+
+void draw_calign(Cairo::RefPtr<Cairo::Context>cr, double size) {
+
+ // Basic units.
+ double delta4 = (size-1)/4.0; // Use unscaled width.
+ double delta8 = delta4/2;
+ if (delta8 < 2) {
+ // Keep a minimum gap of at least one pixel (after stroking).
+ delta8 = 2;
+ }
+
+ // Tip of triangle
+ double tip_x = size/2.0; // Center (also rotation point).
+ double tip_y = size/2.0;
+
+ // Corner triangle position.
+ double outer = size/2.0 - delta8 - delta4;
+
+ // End of line positin
+ double eline = size/2.0 - delta8;
+
+ // Outer line position
+ double oline = size/2.0 + (int)delta4;
+
+ // Inner line position
+ double iline = size/2.0 + (int)delta8;
+
+ // Draw triangle
+ cr->move_to(tip_x, tip_y);
+ cr->line_to(outer, tip_y);
+ cr->line_to(tip_x, outer);
+ cr->close_path();
+
+ // Draw line
+ cr->move_to(iline, iline);
+ cr->line_to(iline, eline);
+ cr->line_to(oline, eline);
+ cr->line_to(oline, oline);
+ cr->line_to(eline, oline);
+ cr->line_to(eline, iline);
+ cr->close_path();
+}
+
+void draw_malign(Cairo::RefPtr<Cairo::Context>cr, double size) {
+
+ // Basic units.
+ double delta4 = (size-1)/4.0; // Use unscaled width.
+ double delta8 = delta4/2;
+ if (delta8 < 2) {
+ // Keep a minimum gap of at least one pixel (after stroking).
+ delta8 = 2;
+ }
+
+ // Tip of triangle
+ double tip_0 = size/2.0;
+ double tip_1 = size/2.0 - delta8;
+
+ // Draw triangles
+ cr->move_to(tip_0, tip_1);
+ cr->line_to(tip_0 - delta4, tip_1 - delta4);
+ cr->line_to(tip_0 + delta4, tip_1 - delta4);
+ cr->close_path();
+
+ cr->move_to(size - tip_1, tip_0);
+ cr->line_to(size - tip_1 + delta4, tip_0 - delta4);
+ cr->line_to(size - tip_1 + delta4, tip_0 + delta4);
+ cr->close_path();
+
+ cr->move_to(size - tip_0, size - tip_1);
+ cr->line_to(size - tip_0 + delta4, size - tip_1 + delta4);
+ cr->line_to(size - tip_0 - delta4, size - tip_1 + delta4);
+ cr->close_path();
+
+ cr->move_to(tip_1, tip_0);
+ cr->line_to(tip_1 - delta4, tip_0 + delta4);
+ cr->line_to(tip_1 - delta4, tip_0 - delta4);
+ cr->close_path();
+
+}
+
+void CanvasItemCtrl::build_cache(int device_scale)
+{
+ if (_width < 2 || _height < 2) {
+ return; // Nothing to render
+ }
+
+ // Get colors
+ guint32 fill = 0x0;
+ guint32 stroke = 0x0;
+ fill = _fill;
+ stroke = _stroke;
+
+ if (_shape != CANVAS_ITEM_CTRL_SHAPE_BITMAP) {
+ if (_width % 2 == 0 || _height % 2 == 0) {
+ std::cerr << "CanvasItemCtrl::build_cache: Width and/or height not odd integer! "
+ << _name << ": width: " << _width << " height: " << _height << std::endl;
+ }
+ }
+
+ // Get memory for cache.
+ int width = _width * device_scale; // Not unsigned or math errors occur!
+ int height = _height * device_scale;
+ int size = width * height;
+
+ if (_cache) delete[] _cache;
+ _cache = new guint32[size];
+ guint32 *p = _cache;
+
+ switch (_shape) {
+
+ case CANVAS_ITEM_CTRL_SHAPE_SQUARE:
+ // Actually any rectanglular shape.
+ for (int i = 0; i < width; ++i) {
+ for (int j = 0; j < width; ++j) {
+ if (i + 1 > device_scale && device_scale < width - i &&
+ j + 1 > device_scale && device_scale < height - j) {
+ *p++ = fill;
+ } else {
+ *p++ = stroke;
+ }
+ }
+ }
+ _built = true;
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_DIAMOND:
+ { // Assume width == height.
+ int m = (width+1)/2;
+
+ for (int i = 0; i < width; ++i) {
+ for (int j = 0; j < height; ++j) {
+ if ( i + j > m-1+device_scale &&
+ (width-1-i) + j > m-1+device_scale &&
+ (width-1-i) + (height-1-j) > m-1+device_scale &&
+ i + (height-1-j) > m-1+device_scale ) {
+ *p++ = fill;
+ } else
+ if ( i + j > m-2 &&
+ (width-1-i) + j > m-2 &&
+ (width-1-i) + (height-1-j) > m-2 &&
+ i + (height-1-j) > m-2 ) {
+ *p++ = stroke;
+ } else {
+ *p++ = 0;
+ }
+ }
+ }
+ _built = true;
+ break;
+ }
+
+ case CANVAS_ITEM_CTRL_SHAPE_CIRCLE:
+ { // Assume width == height.
+ double rs = width/2.0;
+ double rs2 = rs*rs;
+ double rf = rs-device_scale;
+ double rf2 = rf*rf;
+
+ for (int i = 0; i < width; ++i) {
+ for (int j = 0; j < height; ++j) {
+
+ double rx = i - (width /2.0) + 0.5;
+ double ry = j - (height/2.0) + 0.5;
+ double r2 = rx*rx + ry*ry;
+
+ if (r2 < rf2) {
+ *p++ = fill;
+ } else if (r2 < rs2) {
+ *p++ = stroke;
+ } else {
+ *p++ = 0;
+ }
+ }
+ }
+ _built = true;
+ break;
+ }
+
+ case CANVAS_ITEM_CTRL_SHAPE_TRIANGLE:
+ {
+ Geom::Affine m = Geom::Translate(Geom::Point(-width/2.0,-height/2.0));
+ m *= Geom::Rotate(-_angle);
+ m *= Geom::Translate(Geom::Point(width/2.0, height/2.0));
+
+ // Construct an arrowhead (triangle) of maximum size that won't leak out of rectangle
+ // defined by width and height, assuming width == height.
+ double w2 = width/2.0;
+ double h2 = height/2.0;
+ double w2cos = w2 * cos( M_PI/6 );
+ double h2sin = h2 * sin( M_PI/6 );
+ Geom::Point p1s(0, h2);
+ Geom::Point p2s(w2 + w2cos, h2 + h2sin);
+ Geom::Point p3s(w2 + w2cos, h2 - h2sin);
+
+ // Needed for constructing smaller arrowhead below.
+ double theta = atan2( Geom::Point( p2s - p1s ) );
+
+ p1s *= m;
+ p2s *= m;
+ p3s *= m;
+
+ // Construct a smaller arrow head for fill.
+ Geom::Point p1f(device_scale/sin(theta), h2);
+ Geom::Point p2f(w2 + w2cos, h2 - h2sin + device_scale/cos(theta));
+ Geom::Point p3f(w2 + w2cos, h2 + h2sin - device_scale/cos(theta));
+ p1f *= m;
+ p2f *= m;
+ p3f *= m;
+
+ for(int y = 0; y < height; y++) {
+ for(int x = 0; x < width; x++) {
+ Geom::Point point = Geom::Point(x+0.5, y+0.5);
+
+ if (point_inside_triangle(p1f, p2f, p3f, point)) {
+ p[(y*width)+x] = fill;
+
+ } else if (point_inside_triangle(p1s, p2s, p3s, point)) {
+ p[(y*width)+x] = stroke;
+
+ } else {
+ p[(y*width)+x] = 0;
+ }
+ }
+ }
+ break;
+ }
+
+ case CANVAS_ITEM_CTRL_SHAPE_CROSS:
+ // Actually an 'X'.
+ for(int y = 0; y < height; y++) {
+ for(int x = 0; x < width; x++) {
+ if ( abs(x - y) < device_scale ||
+ abs(width - 1 - x - y) < device_scale ) {
+ *p++ = stroke;
+ } else {
+ *p++ = 0;
+ }
+ }
+ }
+ _built = true;
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_PLUS:
+ // Actually an '+'.
+ for(int y = 0; y < height; y++) {
+ for(int x = 0; x < width; x++) {
+ if ( std::abs(x-width/2) < device_scale ||
+ std::abs(y-height/2) < device_scale ) {
+ *p++ = stroke;
+ } else {
+ *p++ = 0;
+ }
+ }
+ }
+ _built = true;
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_DARROW: // Double arrow
+ case CANVAS_ITEM_CTRL_SHAPE_SARROW: // Same shape as darrow but rendered rotated 90 degrees.
+ case CANVAS_ITEM_CTRL_SHAPE_CARROW: // Double corner arrow
+ case CANVAS_ITEM_CTRL_SHAPE_PIVOT: // Fancy "plus"
+ case CANVAS_ITEM_CTRL_SHAPE_SALIGN: // Side align (triangle pointing toward line)
+ case CANVAS_ITEM_CTRL_SHAPE_CALIGN: // Corner align (triangle pointing into "L")
+ case CANVAS_ITEM_CTRL_SHAPE_MALIGN: // Middle align (four triangles poining inward)
+ {
+ double size = _width; // Use unscaled width.
+
+ auto work = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, device_scale * size, device_scale * size);
+ cairo_surface_set_device_scale(work->cobj(), device_scale, device_scale); // No C++ API!
+ auto cr = Cairo::Context::create(work);
+
+ // Rotate around center
+ cr->translate( size/2.0, size/2.0);
+ cr->rotate(_angle);
+ cr->translate(-size/2.0, -size/2.0);
+
+ // Construct path
+ switch (_shape) {
+ case CANVAS_ITEM_CTRL_SHAPE_DARROW:
+ case CANVAS_ITEM_CTRL_SHAPE_SARROW:
+ draw_darrow(cr, size);
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_CARROW:
+ draw_carrow(cr, size);
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_PIVOT:
+ draw_pivot(cr, size);
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_SALIGN:
+ draw_salign(cr, size);
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_CALIGN:
+ draw_calign(cr, size);
+ break;
+
+ case CANVAS_ITEM_CTRL_SHAPE_MALIGN:
+ draw_malign(cr, size);
+ break;
+
+ default:
+ // Shouldn't happen
+ break;
+ }
+
+ // Fill and stroke.
+ cr->set_source_rgba(SP_RGBA32_R_F(_fill),
+ SP_RGBA32_G_F(_fill),
+ SP_RGBA32_B_F(_fill),
+ SP_RGBA32_A_F(_fill));
+ cr->fill_preserve();
+ cr->set_source_rgba(SP_RGBA32_R_F(_stroke),
+ SP_RGBA32_G_F(_stroke),
+ SP_RGBA32_B_F(_stroke),
+ SP_RGBA32_A_F(_stroke));
+ cr->set_line_width(1);
+ cr->stroke();
+
+ // Copy to buffer.
+ work->flush();
+ int strideb = work->get_stride();
+ unsigned char* pxb = work->get_data();
+ guint32 *p = _cache;
+ for (int i = 0; i < device_scale * size; ++i) {
+ guint32 *pb = reinterpret_cast<guint32*>(pxb + i*strideb);
+ for (int j = 0; j < width; ++j) {
+
+ guint32 color = 0x0;
+
+ // Need to un-premultiply alpha and change order argb -> rgba.
+ guint32 alpha = (*pb & 0xff000000) >> 24;
+ if (alpha == 0x0) {
+ color = 0x0;
+ } else {
+ guint32 rgb = unpremul_alpha(*pb & 0xffffff, alpha);
+ color = (rgb << 8) + alpha;
+ }
+
+ *p++ = color;
+ pb++;
+ }
+ }
+ _built = true;
+ break;
+ }
+
+ case CANVAS_ITEM_CTRL_SHAPE_BITMAP:
+ {
+ if (_pixbuf) {
+ unsigned char* px = gdk_pixbuf_get_pixels (_pixbuf);
+ unsigned int rs = gdk_pixbuf_get_rowstride (_pixbuf);
+ for (int y = 0; y < height/device_scale; y++){
+ for (int x = 0; x < width/device_scale; x++) {
+ unsigned char *s = px + rs*y + 4*x;
+ guint32 color;
+ if (s[3] < 0x80) {
+ color = 0;
+ } else if (s[0] < 0x80) {
+ color = _stroke;
+ } else {
+ color = _fill;
+ }
+
+ // Fill in device_scale x device_scale block
+ for (int i = 0; i < device_scale; ++i) {
+ for (int j = 0; j < device_scale; ++j) {
+ guint* p = _cache +
+ (x * device_scale + i) + // Column
+ (y * device_scale + j) * width; // Row
+ *p = color;
+ }
+ }
+ }
+ }
+ } else {
+ std::cerr << "CanvasItemCtrl::build_cache: No bitmap!" << std::endl;
+ guint *p = _cache;
+ for (int y = 0; y < height/device_scale; y++){
+ for (int x = 0; x < width/device_scale; x++) {
+ if (x == y) {
+ *p++ = 0xffff0000;
+ } else {
+ *p++ = 0;
+ }
+ }
+ }
+ }
+ _built = true;
+ break;
+ }
+
+ case CANVAS_ITEM_CTRL_SHAPE_IMAGE:
+ std::cerr << "CanvasItemCtrl::build_cache: image: UNIMPLEMENTED" << std::endl;
+ break;
+
+ default:
+ std::cerr << "CanvasItemCtrl::build_cache: unhandled shape!" << std::endl;
+ }
+}
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-ctrl.h b/src/display/control/canvas-item-ctrl.h
new file mode 100644
index 0000000..4cccc88
--- /dev/null
+++ b/src/display/control/canvas-item-ctrl.h
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_CTRL_H
+#define SEEN_CANVAS_ITEM_CTRL_H
+
+/**
+ * A class to represent a control node.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCtrl
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <memory>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <2geom/point.h>
+
+#include "canvas-item.h"
+#include "canvas-item-enums.h"
+
+#include "enums.h" // SP_ANCHOR_X
+
+namespace Inkscape {
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemCtrl : public CanvasItem {
+
+public:
+ ~CanvasItemCtrl() override;
+ CanvasItemCtrl(CanvasItemGroup *group);
+ CanvasItemCtrl(CanvasItemGroup *group, CanvasItemCtrlType type);
+ CanvasItemCtrl(CanvasItemGroup *group, CanvasItemCtrlType type, Geom::Point const &p);
+ CanvasItemCtrl(CanvasItemGroup *group, CanvasItemCtrlShape shape);
+ CanvasItemCtrl(CanvasItemGroup *group, CanvasItemCtrlShape shape, Geom::Point const &p);
+
+ // Geometry
+ void set_position(Geom::Point const &position);
+
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p);
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+ // Properties
+ void set_fill(guint32 rgba) override;
+ void set_stroke(guint32 rgba) override;
+ void set_shape(int shape);
+ void set_shape_default(); // Use type to determine shape.
+ void set_mode(int mode);
+ void set_mode_default();
+ void set_size(int size);
+ virtual void set_size_via_index(int size_index);
+ void set_size_default(); // Use preference and type to set size.
+ void set_size_extra(int extra); // Used to temporary increase size of ctrl.
+ void set_anchor(SPAnchorType anchor);
+ void set_angle(double angle);
+ void set_type(CanvasItemCtrlType type);
+ void set_pixbuf(GdkPixbuf *pixbuf);
+
+protected:
+ void build_cache(int device_scale);
+
+ // Geometry
+ Geom::Point _position;
+
+ // Display
+ guint32 *_cache = nullptr;
+ bool _built = false;
+
+ // Properties
+ CanvasItemCtrlType _type = CANVAS_ITEM_CTRL_TYPE_DEFAULT;
+ CanvasItemCtrlShape _shape = CANVAS_ITEM_CTRL_SHAPE_SQUARE;
+ CanvasItemCtrlMode _mode = CANVAS_ITEM_CTRL_MODE_XOR;
+ unsigned int _width = 5; // Nominally width == height == size... unless we use a pixmap.
+ unsigned int _height = 5;
+ unsigned int _extra = 0; // Used to temporarily increase size.
+ double _angle = 0.0; // Used for triangles, could be used for arrows.
+ SPAnchorType _anchor = SP_ANCHOR_CENTER;
+ GdkPixbuf *_pixbuf = nullptr;
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_CTRL_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 :
diff --git a/src/display/control/canvas-item-curve.cpp b/src/display/control/canvas-item-curve.cpp
new file mode 100644
index 0000000..a99a154
--- /dev/null
+++ b/src/display/control/canvas-item-curve.cpp
@@ -0,0 +1,236 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to represent a single Bezier control curve, either a line or a cubic Bezier.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCtrlLine and SPCtrlCurve
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <2geom/bezier-curve.h>
+
+#include "canvas-item-curve.h"
+
+#include "color.h" // SP_RGBA_x_F
+
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+/**
+ * Create an null control curve.
+ */
+CanvasItemCurve::CanvasItemCurve(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemCurve:Null";
+ _pickable = false; // For now, nobody gets events from this class!
+}
+
+/**
+ * Create a linear control curve. Points are in document coordinates.
+ */
+CanvasItemCurve::CanvasItemCurve(CanvasItemGroup *group, Geom::Point const &p0, Geom::Point const &p1)
+ : CanvasItem(group)
+ , _curve(std::make_unique<Geom::LineSegment>(p0, p1))
+{
+ _name = "CanvasItemCurve:Line";
+ _pickable = false; // For now, nobody gets events from this class!
+
+ request_update();
+}
+
+/**
+ * Create a cubic Bezier control curve. Points are in document coordinates.
+ */
+CanvasItemCurve::CanvasItemCurve(CanvasItemGroup *group,
+ Geom::Point const &p0, Geom::Point const &p1,
+ Geom::Point const &p2, Geom::Point const &p3)
+ : CanvasItem(group)
+ , _curve(std::make_unique<Geom::CubicBezier>(p0, p1, p2, p3))
+{
+ _name = "CanvasItemCurve:CubicBezier";
+ _pickable = false; // For now, nobody gets events from this class!
+
+ request_update();
+}
+
+/**
+ * Set a linear control curve. Points are in document coordinates.
+ */
+void CanvasItemCurve::set_coords(Geom::Point const &p0, Geom::Point const &p1)
+{
+ _name = "CanvasItemCurve:Line";
+ _curve = std::make_unique<Geom::LineSegment>(p0, p1);
+
+ request_update();
+}
+
+/**
+ * Set a cubic Bezier control curve. Points are in document coordinates.
+ */
+void CanvasItemCurve::set_coords(Geom::Point const &p0, Geom::Point const &p1, Geom::Point const &p2, Geom::Point const &p3)
+{
+ _name = "CanvasItemCurve:CubicBezier";
+ _curve = std::make_unique<Geom::CubicBezier>(p0, p1, p2, p3);
+
+ request_update();
+}
+
+/**
+ * Set stroke width.
+ */
+void CanvasItemCurve::set_width(int w)
+{
+ width = w;
+
+ request_update();
+}
+
+/**
+ * Set background stroke alpha.
+ */
+void CanvasItemCurve::set_bg_alpha(float alpha)
+{
+ bg_alpha = alpha;
+
+ request_update();
+}
+
+/**
+ * Returns distance between point in canvas units and nearest point on curve.
+ */
+double CanvasItemCurve::closest_distance_to(Geom::Point const &p)
+{
+ double d = Geom::infinity();
+ if (_curve) {
+ Geom::BezierCurve curve = *_curve;
+ curve *= _affine; // Document to canvas.
+ Geom::Point n = curve.pointAt(curve.nearestTime(p));
+ d = Geom::distance(p, n);
+ }
+ return d;
+}
+
+/**
+ * Returns true if point p (in canvas units) is within tolerance (canvas units) distance of curve.
+ */
+bool CanvasItemCurve::contains(Geom::Point const &p, double tolerance)
+{
+ return closest_distance_to(p) <= tolerance;
+}
+
+/**
+ * Update and redraw control curve.
+ */
+void CanvasItemCurve::update(Geom::Affine const &affine)
+{
+ if (_affine == affine && !_need_update) {
+ // Nothing to do.
+ return;
+ }
+
+ if (!_curve) {
+ return; // No curve! See node.h.
+ }
+
+ // Queue redraw of old area (erase previous content).
+ request_redraw(); // This is actually never useful as curves are always deleted
+ // and recreated when a node is moved! But keep it in case we
+ // change that. CHECK
+ // Get new bounds
+ _affine = affine;
+
+ // Trade off between updating a larger area (typically twice for Beziers?) vs computation time for bounds.
+ _bounds = _curve->boundsExact(); // Document units.
+ _bounds *= _affine; // Document to canvas.
+ _bounds.expandBy(2); // Room for stroke.
+
+ // Queue redraw of new area
+ request_redraw();
+
+ _need_update = false;
+}
+
+/**
+ * Render curve to screen via Cairo.
+ */
+void CanvasItemCurve::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (!buf) {
+ std::cerr << "CanvasItemCurve::Render: No buffer!" << std::endl;
+ return;
+ }
+
+ if (!_curve) {
+ // Curve not defined (see node.h).
+ return;
+ }
+
+ if (!_visible) {
+ // Hidden
+ return;
+ }
+
+ if (_curve->isDegenerate()) {
+ // Nothing to render!
+ return;
+ }
+
+ Geom::BezierCurve curve = *_curve;
+ curve *= _affine; // Document to canvas.
+ curve *= Geom::Translate(-buf->rect.min()); // Canvas to screen.
+
+ buf->cr->save();
+
+ buf->cr->begin_new_path();
+
+ if (curve.size() == 2) {
+ // Line
+ buf->cr->move_to(curve[0].x(), curve[0].y());
+ buf->cr->line_to(curve[1].x(), curve[1].y());
+ } else {
+ // Curve
+ buf->cr->move_to(curve[0].x(), curve[0].y());
+ buf->cr->curve_to(curve[1].x(), curve[1].y(), curve[2].x(), curve[2].y(), curve[3].x(), curve[3].y());
+ }
+
+ buf->cr->set_source_rgba(1.0, 1.0, 1.0, bg_alpha);
+ buf->cr->set_line_width(background_width);
+ buf->cr->stroke_preserve();
+
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_stroke), SP_RGBA32_G_F(_stroke),
+ SP_RGBA32_B_F(_stroke), SP_RGBA32_A_F(_stroke));
+ buf->cr->set_line_width(width);
+ buf->cr->stroke();
+
+ // Uncomment to show bounds
+ // Geom::Rect bounds = _bounds;
+ // bounds.expandBy(-1);
+ // bounds -= buf->rect.min();
+ // buf->cr->set_source_rgba(1.0, 0.0, 0.0, 1.0);
+ // buf->cr->rectangle(bounds.min().x(), bounds.min().y(), bounds.width(), bounds.height());
+ // buf->cr->stroke();
+
+ buf->cr->restore();
+}
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-curve.h b/src/display/control/canvas-item-curve.h
new file mode 100644
index 0000000..84d6511
--- /dev/null
+++ b/src/display/control/canvas-item-curve.h
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_CURVE_H
+#define SEEN_CANVAS_ITEM_CURVE_H
+
+/**
+ * A class to represent a single Bezier control curve.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCtrlLine and SPCtrlCurve
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <memory>
+#include <2geom/path.h>
+
+#include "canvas-item.h"
+
+namespace Inkscape {
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemCurve : public CanvasItem {
+
+public:
+ CanvasItemCurve(CanvasItemGroup *group);
+ CanvasItemCurve(CanvasItemGroup *group, Geom::Point const &p0, Geom::Point const &p1);
+ CanvasItemCurve(CanvasItemGroup *group, Geom::Point const &p0, Geom::Point const &p1,
+ Geom::Point const &p2, Geom::Point const &p3);
+
+ // Geometry
+ void set_coords(Geom::Point const &p0, Geom::Point const &p1);
+ void set_coords(Geom::Point const &p0, Geom::Point const &p1, Geom::Point const &p2, Geom::Point const &p3);
+ void set(Geom::BezierCurve &curve);
+ void set_width(int w);
+ void set_bg_alpha(float alpha);
+ bool is_line() { return _curve->size() == 2; }
+
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p); // Maybe not needed
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+ // Properties
+ void set_is_fill(bool is_fill) { _is_fill = is_fill; }
+ bool get_is_fill() { return _is_fill; }
+ void set_corner0(int corner0) { _corner0 = corner0; } // Used for meshes
+ int get_corner0() { return _corner0; }
+ void set_corner1(int corner1) { _corner1 = corner1; }
+ int get_corner1() { return _corner1; }
+
+protected:
+ std::unique_ptr<Geom::BezierCurve> _curve;
+ bool _is_fill = true; // Fill or stroke, used by meshes.
+
+ int width = 1;
+ int background_width = 3; // this should be an odd number so that the background appears on both the sides of the curve.
+ float bg_alpha = 0.5f;
+ int _corner0 = -1; // For meshes
+ int _corner1 = -1; // For meshes
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_CURVE_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 :
diff --git a/src/display/control/canvas-item-drawing.cpp b/src/display/control/canvas-item-drawing.cpp
new file mode 100644
index 0000000..17750b7
--- /dev/null
+++ b/src/display/control/canvas-item-drawing.cpp
@@ -0,0 +1,296 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to render the SVG drawing.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of _SPCavasArena.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-item-drawing.h"
+
+#include "desktop.h"
+
+#include "preferences.h"
+
+#include "display/cairo-utils.h"
+#include "display/drawing.h"
+#include "display/drawing-context.h"
+#include "display/drawing-item.h"
+#include "display/drawing-group.h"
+#include "display/drawing-surface.h"
+
+#include "ui/widget/canvas.h"
+#include "ui/modifiers.h"
+
+namespace Inkscape {
+
+struct CachePref2Observer : public Inkscape::Preferences::Observer {
+ CachePref2Observer(Inkscape::CanvasItemDrawing *item)
+ : Inkscape::Preferences::Observer("/options/renderingcache")
+ , _canvas_item_drawing(item)
+ {
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ std::vector<Inkscape::Preferences::Entry> v = prefs->getAllEntries(observed_path);
+ for (const auto & i : v) {
+ notify(i);
+ }
+ prefs->addObserver(*this);
+ }
+ void notify(Inkscape::Preferences::Entry const &v) override {
+ Glib::ustring name = v.getEntryName();
+ if (name == "size") {
+ _canvas_item_drawing->get_drawing()->setCacheBudget((1 << 20) * v.getIntLimited(64, 0, 4096));
+ }
+ }
+ Inkscape::CanvasItemDrawing *_canvas_item_drawing;
+};
+
+/**
+ * Create the drawing. One per window!
+ */
+CanvasItemDrawing::CanvasItemDrawing(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemDrawing";
+ _pickable = true;
+
+ _drawing = new Inkscape::Drawing(this);
+ _drawing->delta = 1.0; // Default
+ auto root = new Inkscape::DrawingGroup(*_drawing);
+ root->setPickChildren(true);
+ _drawing->setRoot(root);
+
+ // _drawing->signal_request_update.connect(...); Not needed now.
+ // _drawing->signal_request_render.connect(...); Not needed now.
+ // _drawing->signal_item_deleted.connect(...); Not needed now.
+
+ _observer = new CachePref2Observer(this);
+}
+
+CanvasItemDrawing::~CanvasItemDrawing()
+{
+ delete _observer;
+ delete _drawing;
+}
+
+/**
+ * Returns distance between point in canvas units and nearest point on drawing.
+ */
+double CanvasItemDrawing::closest_distance_to(Geom::Point const &p)
+{
+ double d = Geom::infinity();
+ std::cerr << "CanvasItemDrawing::closest_distance_to: Not implemented!" << std::endl;
+ return d;
+}
+
+/**
+ * Returns true if point p (in canvas units) is inside some object in drawing.
+ */
+bool CanvasItemDrawing::contains(Geom::Point const &p, double tolerance)
+{
+ if (tolerance != 0) {
+ std::cerr << "CanvasItemDrawing::contains: Non-zero tolerance not implemented!" << std::endl;
+ }
+
+ _drawing->update(Geom::IntRect::infinite(), DrawingItem::STATE_PICK | DrawingItem::STATE_BBOX);
+ _picked_item = _drawing->pick(p, _drawing->delta, _sticky);
+
+ if (_picked_item) {
+ // This will trigger a signal that is handled by our event handler. Seems a bit of a
+ // round-a-bout way of doing things but it matches what other pickable canvas-item classes
+ // do.
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * Update and redraw drawing.
+ */
+void CanvasItemDrawing::update(Geom::Affine const &affine)
+{
+ auto new_affine = affine;
+
+ // Correct for y-axis. This should not be here!!!!
+ if (auto *desktop = _canvas->get_desktop()) {
+ new_affine = desktop->doc2dt() * new_affine;
+ }
+
+ // if (_affine == new_affine && !_need_update) {
+ // // Nothing to do.
+ // return;
+ // }
+
+ _ctx.ctm = new_affine; // TODO Remove _ctx.ctm... it's exactly the same as _affine!
+
+ unsigned reset = (_affine != new_affine ? DrawingItem::STATE_ALL : 0);
+
+ _affine = new_affine;
+
+ _drawing->update(Geom::IntRect::infinite(), DrawingItem::STATE_ALL, reset);
+
+ Geom::OptIntRect bbox = _drawing->root()->visualBounds();
+ if (bbox) {
+ _bounds = *bbox;
+ _bounds.expandBy(1); // Avoid aliasing artifacts.
+ }
+
+ if (_cursor) {
+ /* Mess with enter/leave notifiers */
+ DrawingItem *new_drawing_item = _drawing->pick(_c, _delta, _sticky);
+ if (_active_item != new_drawing_item) {
+
+ GdkEventCrossing ec;
+ ec.window = _canvas->get_window()->gobj();
+ ec.send_event = true;
+ ec.subwindow = ec.window;
+ ec.time = GDK_CURRENT_TIME;
+ ec.x = _c.x();
+ ec.y = _c.y();
+
+ /* fixme: Why? */
+ if (_active_item) {
+ ec.type = GDK_LEAVE_NOTIFY;
+ _drawing_event_signal.emit((GdkEvent *) &ec, _active_item);
+ }
+
+ _active_item = new_drawing_item;
+
+ if (_active_item) {
+ ec.type = GDK_ENTER_NOTIFY;
+ _drawing_event_signal.emit((GdkEvent *) &ec, _active_item);
+ }
+ }
+ }
+
+ _need_update = false;
+}
+
+/**
+ * Render drawing to screen via Cairo.
+ */
+void CanvasItemDrawing::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (!buf) {
+ std::cerr << "CanvasItemDrawing::Render: No buffer!" << std::endl;
+ return;
+ }
+
+ if (buf->rect.hasZeroArea()) {
+ return;
+ }
+
+ Inkscape::DrawingContext dc(buf->cr->cobj(), buf->rect.min());
+ _drawing->update();
+ _drawing->render(dc, buf->rect);
+}
+
+/**
+ * Handle events directed at the drawing. We first attempt to handle them here.
+ */
+bool CanvasItemDrawing::handle_event(GdkEvent *event)
+{
+ bool retval = false;
+
+ switch (event->type) {
+ case GDK_ENTER_NOTIFY:
+ if (!_cursor) {
+ if (_active_item) {
+ std::cerr << "CanvasItemDrawing::event_handler: cursor entered drawing with an active item!" << std::endl;
+ }
+ _cursor = true;
+
+ /* TODO ... event -> arena transform? */
+ _c = Geom::Point(event->crossing.x, event->crossing.y);
+
+ /* fixme: Not sure abut this, but seems the right thing (Lauris) */
+ //_drawing->update(Geom::IntRect::infinite(), _ctx, DrawingItem::STATE_PICK | DrawingItem::STATE_BBOX, 0);
+ _active_item = _drawing->pick(_c, _drawing->delta, _sticky);
+ retval = _drawing_event_signal.emit(event, _active_item);
+ }
+ break;
+
+ case GDK_LEAVE_NOTIFY:
+ if (_cursor) {
+ retval = _drawing_event_signal.emit(event, _active_item);
+ _active_item = nullptr;
+ _cursor = false;
+ }
+ break;
+
+ case GDK_MOTION_NOTIFY:
+ {
+ /* TODO ... event -> arena transform? */
+ _c = Geom::Point(event->motion.x, event->motion.y);
+
+ /* fixme: Not sure abut this, but seems the right thing (Lauris) */
+ //_drawing->update(Geom::IntRect::infinite(), _ctx, DrawingItem::STATE_PICK | DrawingItem::STATE_BBOX);
+
+ auto new_drawing_item = _drawing->pick(_c, _drawing->delta, _sticky);
+ if (_active_item != new_drawing_item) {
+
+ GdkEventCrossing ec;
+ ec.window = event->motion.window;
+ ec.send_event = event->motion.send_event;
+ ec.subwindow = event->motion.window;
+ ec.time = event->motion.time;
+ ec.x = event->motion.x;
+ ec.y = event->motion.y;
+
+ /* fixme: What is wrong? */
+ if (_active_item) {
+ ec.type = GDK_LEAVE_NOTIFY;
+ retval = _drawing_event_signal.emit((GdkEvent *) &ec, _active_item);
+ }
+
+ _active_item = new_drawing_item;
+
+ if (_active_item) {
+ ec.type = GDK_ENTER_NOTIFY;
+ retval = _drawing_event_signal.emit((GdkEvent *) &ec, _active_item);
+ }
+ }
+ retval = retval || _drawing_event_signal.emit(event, _active_item);
+ break;
+ }
+
+ case GDK_SCROLL:
+ {
+ if (Modifiers::Modifier::get(Modifiers::Type::CANVAS_ZOOM)->active(event->scroll.state)) {
+ /* Zoom is emitted by the canvas as well, ignore here */
+ return false;
+ }
+ retval = _drawing_event_signal.emit(event, _active_item);
+ break;
+ }
+
+ default:
+ /* Just send event */
+ retval = _drawing_event_signal.emit(event, _active_item);
+ break;
+ }
+
+ return retval;
+}
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-drawing.h b/src/display/control/canvas-item-drawing.h
new file mode 100644
index 0000000..6e8a206
--- /dev/null
+++ b/src/display/control/canvas-item-drawing.h
@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_DRAWING_H
+#define SEEN_CANVAS_ITEM_DRAWING_H
+
+/**
+ * A class to render the SVG drawing.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of _SPCanvasArena.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <sigc++/sigc++.h>
+
+
+#include "canvas-item.h"
+#include "display/drawing-item.h" // Only for ctx... which should be remove (it's the same as _affine!).
+
+namespace Inkscape {
+
+class CachePref2Observer;
+
+class Drawing;
+class DrawingItem;
+class Updatecontext;
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemDrawing : public CanvasItem {
+
+public:
+ CanvasItemDrawing(CanvasItemGroup *group);
+ ~CanvasItemDrawing() override;
+
+
+ // Geometry
+ UpdateContext get_context() { return _ctx; } // TODO Remove this as ctx only contains affine.
+
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p);
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+ Inkscape::Drawing * get_drawing() { return _drawing; }
+
+ // Drawing items
+ void set_active(Inkscape::DrawingItem *active) { _active_item = active; }
+ Inkscape::DrawingItem *get_active() { return _active_item; }
+
+ // Events
+ bool handle_event(GdkEvent* event) override;
+ void set_sticky(bool sticky) { _sticky = sticky; }
+
+ // Signals
+ sigc::connection connect_drawing_event(sigc::slot<bool, GdkEvent*, Inkscape::DrawingItem *> slot) {
+ return _drawing_event_signal.connect(slot);
+ }
+
+protected:
+
+ // Geometry
+
+ // Selection
+ Geom::Point _c;
+ double _delta = Geom::infinity();
+ Inkscape::DrawingItem *_active_item = nullptr;
+ Inkscape::DrawingItem *_picked_item = nullptr;
+
+ // Display
+ Inkscape::Drawing *_drawing;
+ Inkscape::UpdateContext _ctx; // TODO Remove this... it's the same as _affine!
+
+ // Events
+ bool _cursor = false;
+ bool _sticky = false; // Pick anything, even if hidden.
+
+ // Properties
+ CachePref2Observer *_observer = nullptr;
+
+ // Signals
+ sigc::signal<bool, GdkEvent*, Inkscape::DrawingItem *> _drawing_event_signal;
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_DRAWING_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 :
diff --git a/src/display/control/canvas-item-enums.h b/src/display/control/canvas-item-enums.h
new file mode 100644
index 0000000..37561b5
--- /dev/null
+++ b/src/display/control/canvas-item-enums.h
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_ENUMS_H
+#define SEEN_CANVAS_ITEM_ENUMS_H
+
+/**
+ * Enums for CanvasControlItem's.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ */
+
+namespace Inkscape {
+
+enum CanvasItemColor {
+ CANVAS_ITEM_PRIMARY,
+ CANVAS_ITEM_SECONDARY,
+ CANVAS_ITEM_TERTIARY
+};
+
+enum CanvasItemCtrlShape {
+ CANVAS_ITEM_CTRL_SHAPE_SQUARE,
+ CANVAS_ITEM_CTRL_SHAPE_DIAMOND,
+ CANVAS_ITEM_CTRL_SHAPE_CIRCLE,
+ CANVAS_ITEM_CTRL_SHAPE_TRIANGLE,
+ CANVAS_ITEM_CTRL_SHAPE_CROSS,
+ CANVAS_ITEM_CTRL_SHAPE_PLUS,
+ CANVAS_ITEM_CTRL_SHAPE_PIVOT, // Fancy "plus"
+ CANVAS_ITEM_CTRL_SHAPE_DARROW, // Double headed arrow.
+ CANVAS_ITEM_CTRL_SHAPE_SARROW, // Double headed arrow, rotated (skew).
+ CANVAS_ITEM_CTRL_SHAPE_CARROW, // Double headed curved arrow.
+ CANVAS_ITEM_CTRL_SHAPE_SALIGN, // Side alignment.
+ CANVAS_ITEM_CTRL_SHAPE_CALIGN, // Corner alignment.
+ CANVAS_ITEM_CTRL_SHAPE_MALIGN, // Center (middle) alignment.
+ CANVAS_ITEM_CTRL_SHAPE_BITMAP,
+ CANVAS_ITEM_CTRL_SHAPE_IMAGE,
+ CANVAS_ITEM_CTRL_SHAPE_LINE
+};
+
+// Applies to control points.
+enum CanvasItemCtrlType {
+ CANVAS_ITEM_CTRL_TYPE_DEFAULT,
+ CANVAS_ITEM_CTRL_TYPE_ADJ_HANDLE, // Stretch & Scale
+ CANVAS_ITEM_CTRL_TYPE_ADJ_SKEW,
+ CANVAS_ITEM_CTRL_TYPE_ADJ_ROTATE,
+ CANVAS_ITEM_CTRL_TYPE_ADJ_CENTER,
+ CANVAS_ITEM_CTRL_TYPE_ADJ_SALIGN,
+ CANVAS_ITEM_CTRL_TYPE_ADJ_CALIGN,
+ CANVAS_ITEM_CTRL_TYPE_ADJ_MALIGN,
+ CANVAS_ITEM_CTRL_TYPE_ANCHOR,
+ CANVAS_ITEM_CTRL_TYPE_POINT,
+ CANVAS_ITEM_CTRL_TYPE_ROTATE,
+ CANVAS_ITEM_CTRL_TYPE_CENTER,
+ CANVAS_ITEM_CTRL_TYPE_SIZER,
+ CANVAS_ITEM_CTRL_TYPE_SHAPER,
+ CANVAS_ITEM_CTRL_TYPE_LPE,
+ CANVAS_ITEM_CTRL_TYPE_NODE_AUTO,
+ CANVAS_ITEM_CTRL_TYPE_NODE_CUSP,
+ CANVAS_ITEM_CTRL_TYPE_NODE_SMOOTH,
+ CANVAS_ITEM_CTRL_TYPE_NODE_SYMETRICAL,
+ CANVAS_ITEM_CTRL_TYPE_INVISIPOINT
+};
+
+enum CanvasItemCtrlMode {
+ CANVAS_ITEM_CTRL_MODE_COLOR,
+ CANVAS_ITEM_CTRL_MODE_XOR,
+ CANVAS_ITEM_CTRL_MODE_DESATURATED_XOR,
+ CANVAS_ITEM_CTRL_MODE_GRAYSCALED_XOR
+};
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_ENUMS_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 :
diff --git a/src/display/control/canvas-item-grid.cpp b/src/display/control/canvas-item-grid.cpp
new file mode 100644
index 0000000..2965b86
--- /dev/null
+++ b/src/display/control/canvas-item-grid.cpp
@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to represent a grid. All the magic happens elsewhere.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of GridCanvasItem.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-item-grid.h"
+
+#include "canvas-grid.h"
+
+#include "color.h" // SP_RGBA_x_F
+
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+/**
+ * Create an null control grid.
+ */
+CanvasItemGrid::CanvasItemGrid(CanvasItemGroup *group, CanvasGrid *grid)
+ : CanvasItem(group)
+ , _grid(grid)
+{
+ _name = "CanvasItemGrid:";
+ _name += grid->getName(grid->getGridType());
+ _pickable = false; // For now, nobody gets events from this class!
+ _bounds = Geom::Rect(-Geom::infinity(), -Geom::infinity(), Geom::infinity(), Geom::infinity());
+
+ request_update(); // Update affine
+}
+
+/**
+ * Destructor: must remove ourself from the CanvasGrid's vector of CanvasItemGrids.
+ */
+CanvasItemGrid::~CanvasItemGrid()
+{
+ if (_grid) {
+ _grid->removeCanvasItem(this);
+ }
+}
+
+/**
+ * Returns distance between point in canvas units and nearest point on grid.
+ */
+double CanvasItemGrid::closest_distance_to(Geom::Point const &p)
+{
+ double d = Geom::infinity();
+ std::cerr << "CanvasItemGrid::closest_distance_to: Not implemented!" << std::endl;
+ return d;
+}
+
+/**
+ * Returns true if point p (in canvas units) is within tolerance (canvas units) distance of grid.
+ */
+bool CanvasItemGrid::contains(Geom::Point const &p, double tolerance)
+{
+ return false; // We're not pickable!
+}
+
+/**
+ * Update and redraw control grid.
+ */
+void CanvasItemGrid::update(Geom::Affine const &affine)
+{
+ if (_affine == affine && !_need_update) {
+ // Nothing to do.
+ return;
+ }
+
+ _affine = affine;
+ _grid->Update(affine, 0); // TODO: Remove flag (not used).
+ _need_update = false;
+
+ // Queue redraw of grid area
+ request_redraw();
+}
+
+/**
+ * Render grid to screen via Cairo.
+ */
+void CanvasItemGrid::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (!buf) {
+ std::cerr << "CanvasItemGrid::Render: No buffer!" << std::endl;
+ return;
+ }
+
+ if (!_visible) {
+ // Hidden
+ return;
+ }
+
+ if (!_grid->isVisible()) {
+ // Hidden: Grid code doesn't set CanvasItem::visible!
+ return;
+ }
+
+ _grid->Render(buf);
+}
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-grid.h b/src/display/control/canvas-item-grid.h
new file mode 100644
index 0000000..f858c57
--- /dev/null
+++ b/src/display/control/canvas-item-grid.h
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_GRID_H
+#define SEEN_CANVAS_ITEM_GRID_H
+
+/**
+ * A class to represent a grid.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of GridCanvasItem.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <2geom/point.h>
+#include <2geom/transforms.h>
+
+#include "canvas-item.h"
+
+namespace Inkscape {
+
+class CanvasGrid;
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemGrid : public CanvasItem {
+
+public:
+ CanvasItemGrid(CanvasItemGroup *group, CanvasGrid *grid);
+ ~CanvasItemGrid() override;
+
+ // Geometry
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p); // Maybe not needed
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+protected:
+ CanvasGrid *_grid = nullptr;
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_GRID_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 :
diff --git a/src/display/control/canvas-item-group.cpp b/src/display/control/canvas-item-group.cpp
new file mode 100644
index 0000000..8e53857
--- /dev/null
+++ b/src/display/control/canvas-item-group.cpp
@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A CanvasItem that contains other CanvasItem's.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasGroup
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-item-group.h"
+#include "canvas-item-ctrl.h" // Update sizes
+
+namespace Inkscape {
+
+CanvasItemGroup::CanvasItemGroup(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemGroup";
+ _pickable = true; // For now all groups are pickable... look into turning this off for some groups (e.g. temp).
+}
+
+CanvasItemGroup::~CanvasItemGroup()
+{
+ while (!items.empty()) {
+ CanvasItem & item = items.front();
+ remove(&item);
+ }
+
+ if (_parent) {
+ _parent->remove(this, false); // remove() should not delete this or we'll double delete!
+ }
+}
+
+void CanvasItemGroup::add(CanvasItem *item)
+{
+#ifdef CANVAS_ITEM_DEBUG
+ std::cout << "CanvasItemGroup::add: " << item->get_name() << " to " << _name << " " << items.size() << std::endl;
+#endif
+ items.push_back(*item);
+ // canvas request update
+}
+
+void CanvasItemGroup::remove(CanvasItem *item, bool Delete)
+{
+#ifdef CANVAS_ITEM_DEBUG
+ std::cout << "CanvasItemGroup::remove: " << item->get_name() << " from " << _name << " " << items.size() << std::endl;
+#endif
+ auto position = items.iterator_to(*item);
+ if (position != items.end()) {
+ position->set_parent(nullptr);
+ items.erase(position);
+ if (Delete) {
+ delete (&*position); // An item directly deleted should not be deleted here.
+ }
+ }
+}
+
+void CanvasItemGroup::update(Geom::Affine const &affine)
+{
+ if (_affine == affine && !_need_update) {
+ // Nothing to do.
+ return;
+ }
+
+ _affine = affine;
+ _need_update = false;
+
+ _bounds = Geom::Rect(); // Zero
+
+ // Update all children and calculate new bounds.
+ for (auto & item : items) {
+ // We don't need to update what is not visible
+ if (!item.is_visible()) continue;
+ item.update(_affine);
+ _bounds.unionWith(item.get_bounds());
+ }
+}
+
+void CanvasItemGroup::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (_visible) {
+ if (_bounds.interiorIntersects(buf->rect)) {
+ for (auto & item : items) {
+ item.render(buf);
+ }
+ }
+ }
+}
+
+// Return last visible and pickable item that contains point.
+// SPCanvasGroup returned distance but it was not used.
+CanvasItem* CanvasItemGroup::pick_item(Geom::Point& p)
+{
+#ifdef CANVAS_ITEM_DEBUG
+ std::cout << "CanvasItemGroup::pick_item:" << std::endl;
+ std::cout << " PICKING: In group: " << _name << " bounds: " << _bounds << std::endl;
+#endif
+ for (auto item = items.rbegin(); item != items.rend(); ++item) { // C++20 will allow us to loop in reverse.
+#ifdef CANVAS_ITEM_DEBUG
+ std::cout << " PICKING: Checking: " << item->get_name() << " bounds: " << item->get_bounds() << std::endl;
+#endif
+ CanvasItem* picked_item = nullptr;
+ if (item->is_visible() &&
+ item->is_pickable() &&
+ item->contains(p) ) {
+
+ auto group = dynamic_cast<CanvasItemGroup *>(&*item);
+ if (group) {
+ picked_item = group->pick_item(p);
+ } else {
+ picked_item = &*item;
+ }
+ }
+
+ if (picked_item != nullptr) {
+#ifdef CANVAS_ITEM_DEBUG
+ std::cout << " PICKING: pick_item: " << picked_item->get_name() << std::endl;
+#endif
+ return picked_item;
+ }
+ }
+
+ return nullptr;
+}
+
+void CanvasItemGroup::update_canvas_item_ctrl_sizes(int size_index)
+{
+ for (auto & item : items) {
+ auto ctrl = dynamic_cast<CanvasItemCtrl *>(&item);
+ if (ctrl) {
+ // We can't use set_size_default as the preference file is updated ->after<- the signal is emitted!
+ ctrl->set_size_via_index(size_index);
+ }
+ auto group = dynamic_cast<CanvasItemGroup *>(&item);
+ if (group) {
+ group->update_canvas_item_ctrl_sizes(size_index);
+ }
+ }
+}
+
+} // Namespace Inkscape
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-group.h b/src/display/control/canvas-item-group.h
new file mode 100644
index 0000000..27cb0da
--- /dev/null
+++ b/src/display/control/canvas-item-group.h
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_GROUP_H
+#define SEEN_CANVAS_ITEM_GROUP_H
+
+/**
+ * A CanvasItem that contains other CanvasItem's.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasGroup
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+//#include <2geom/rect.h>
+#include <boost/intrusive/list.hpp>
+
+#include "canvas-item.h"
+
+namespace Inkscape {
+
+class CanvasItemGroup : public CanvasItem {
+
+public:
+ CanvasItemGroup(CanvasItemGroup* group = nullptr);
+ ~CanvasItemGroup() override;
+
+ // Structure
+ void add(CanvasItem *item);
+ void remove(CanvasItem *item, bool Delete = true);
+
+ void update(Geom::Affine const &affine) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+ // Selection
+ CanvasItem* pick_item(Geom::Point &p);
+
+ CanvasItemList & get_items() { return items; }
+
+ // Properties
+ void update_canvas_item_ctrl_sizes(int size_index);
+
+protected:
+
+private:
+public:
+ // TODO: Make private (used in canvas-item.cpp).
+ CanvasItemList items; // Used to speed deletion.
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_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 :
diff --git a/src/display/control/canvas-item-guideline.cpp b/src/display/control/canvas-item-guideline.cpp
new file mode 100644
index 0000000..6855701
--- /dev/null
+++ b/src/display/control/canvas-item-guideline.cpp
@@ -0,0 +1,343 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to represent a control guide line.
+ */
+
+/*
+ * Authors:
+ * Tavmjong Bah - Rewrite of SPGuideLine
+ * Rafael Siejakowski - Tweaks to handle appearance
+ *
+ * Copyright (C) 2020-2022 the Authors.
+ *
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-item-guideline.h"
+
+#include <2geom/line.h>
+
+#include "canvas-item-ctrl.h"
+
+#include "desktop.h" // Canvas orientation so label is orientated correctly.
+
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+/**
+ * Create a control guide line. Points are in document units.
+ */
+CanvasItemGuideLine::CanvasItemGuideLine(CanvasItemGroup *group, Glib::ustring label,
+ Geom::Point const &origin, Geom::Point const &normal)
+ : CanvasItem(group)
+ , _origin(origin)
+ , _normal(normal)
+ , _label(std::move(label))
+{
+ _name = "CanvasItemGuideLine:" + _label;
+ _pickable = true; // For now, everybody gets events from this class!
+
+ // Required when rotating canvas:
+ _bounds = Geom::Rect(-Geom::infinity(), -Geom::infinity(), Geom::infinity(), Geom::infinity());
+
+ // Control to move guide line.
+ _origin_ctrl = std::make_unique<CanvasItemGuideHandle>(group, _origin, this);
+ _origin_ctrl->set_name("CanvasItemGuideLine:Ctrl:" + _label);
+ _origin_ctrl->set_size_default();
+ _origin_ctrl->set_pickable(true); // The handle will also react to dragging
+ set_locked(false); // Init _origin_ctrl shape and stroke.
+}
+
+CanvasItemGuideLine::~CanvasItemGuideLine() = default;
+
+/**
+ * Sets origin of guide line (place where handle is located).
+ */
+void CanvasItemGuideLine::set_origin(Geom::Point const &origin)
+{
+ if (_origin != origin) {
+ _origin = origin;
+ _origin_ctrl->set_position(_origin);
+ request_update();
+ }
+}
+
+/**
+ * Sets orientation of guide line.
+ */
+void CanvasItemGuideLine::set_normal(Geom::Point const &normal)
+{
+ if (_normal != normal) {
+ _normal = normal;
+ request_update();
+ }
+}
+
+/**
+ * Sets the inverted nature of the line
+ */
+void CanvasItemGuideLine::set_inverted(bool inverted)
+{
+ if (_inverted != inverted) {
+ _inverted = inverted;
+ request_update();
+ }
+}
+
+
+/**
+ * Returns distance between point in canvas units and nearest point on guideLine.
+ */
+double CanvasItemGuideLine::closest_distance_to(Geom::Point const &p)
+{
+ // Maybe store guide as a Geom::Line?
+ Geom::Line guide =
+ Geom::Line::from_origin_and_vector(_origin, Geom::rot90(_normal));
+ guide *= _affine;
+ return Geom::distance(p, guide);
+}
+
+/**
+ * Returns true if point p (in canvas units) is within tolerance (canvas units) distance of guideLine (or 1 if tolerance is zero).
+ */
+bool CanvasItemGuideLine::contains(Geom::Point const &p, double tolerance)
+{
+ if (tolerance == 0) {
+ tolerance = 1; // Can't pick of zero!
+ }
+
+ return closest_distance_to(p) < tolerance;
+}
+
+/**
+ * Returns the pointer to the origin control (the "dot")
+ */
+CanvasItemGuideHandle* CanvasItemGuideLine::dot() const
+{
+ return _origin_ctrl.get();
+}
+
+/**
+ * Update and redraw control guideLine.
+ */
+void CanvasItemGuideLine::update(Geom::Affine const &affine)
+{
+ if (_affine == affine && !_need_update) {
+ // Nothing to do.
+ return;
+ }
+
+ _affine = affine;
+
+ // Queue redraw of new area (and old too).
+ request_redraw();
+
+ _need_update = false;
+}
+
+/**
+ * Render guideLine to screen via Cairo.
+ */
+void CanvasItemGuideLine::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (!buf) {
+ std::cerr << "CanvasItemGuideLine::Render: No buffer!" << std::endl;
+ return;
+ }
+
+ if (!_visible) {
+ // Hidden
+ return;
+ }
+
+ // Document to canvas
+ Geom::Point const normal = _normal * _affine.withoutTranslation(); // Direction only
+ Geom::Point const origin = _origin * _affine;
+
+ /* Need to use floor()+0.5 such that Cairo will draw us lines with a width of a single pixel,
+ * without any aliasing. For this we need to position the lines at exactly half pixels, see
+ * https://www.cairographics.org/FAQ/#sharp_lines
+ * Must be consistent with the pixel alignment of the grid lines, see CanvasXYGrid::Render(),
+ * and the drawing of the rulers.
+ * Lastly, the origin control is also pixel-aligned and we want to visually cut through its
+ * exact center.
+ */
+ Geom::Point const aligned_origin = origin.floor() + Geom::Point(0.5, 0.5);
+
+ // Set up the Cairo rendering context
+ Cairo::RefPtr<Cairo::Context> ctx = buf->cr;
+ ctx->save();
+ ctx->translate(-buf->rect.left(), -buf->rect.top()); // Canvas to screen
+ ctx->set_source_rgba(SP_RGBA32_R_F(_stroke), SP_RGBA32_G_F(_stroke),
+ SP_RGBA32_B_F(_stroke), SP_RGBA32_A_F(_stroke));
+ ctx->set_line_width(1);
+
+ if (_inverted) {
+ // operator not available in cairo C++ bindings
+ cairo_set_operator(ctx->cobj(), CAIRO_OPERATOR_DIFFERENCE);
+ }
+
+ if (!_label.empty()) { // Render text label
+ ctx->save();
+ ctx->translate(aligned_origin.x(), aligned_origin.y());
+
+ SPDesktop *desktop = nullptr;
+ if (_canvas) {
+ desktop = _canvas->get_desktop();
+ }
+ ctx->rotate(atan2(normal.cw()) + M_PI * (desktop && desktop->is_yaxisdown() ? 1 : 0));
+ ctx->translate(0, -(_origin_ctrl->radius() + LABEL_SEP)); // Offset by dot radius + 2
+ ctx->move_to(0, 0);
+ ctx->show_text(_label);
+ ctx->restore();
+ }
+
+ // Draw guide.
+ // Special case: horizontal and vertical lines (easier calculations)
+
+ // Don't use isHorizontal()/isVertical() as they test only exact matches.
+ if (Geom::are_near(normal.y(), 0.0)) {
+ // Vertical
+ double const position = aligned_origin.x();
+ ctx->move_to(position, buf->rect.top() + 0.5);
+ ctx->line_to(position, buf->rect.bottom() - 0.5);
+ } else if (Geom::are_near(normal.x(), 0.0)) {
+ // Horizontal
+ double position = aligned_origin.y();
+ ctx->move_to(buf->rect.left() + 0.5, position);
+ ctx->line_to(buf->rect.right() - 0.5, position);
+ } else {
+ // Angled
+ Geom::Line line = Geom::Line::from_origin_and_vector(aligned_origin, Geom::rot90(normal));
+
+ // Find intersections of the line with buf rectangle. There should be zero or two.
+ std::vector<Geom::Point> intersections;
+ for (unsigned i = 0; i < 4; ++i) {
+ Geom::LineSegment side(buf->rect.corner(i), buf->rect.corner((i+1)%4));
+ try {
+ Geom::OptCrossing oc = Geom::intersection(line, side);
+ if (oc) {
+ intersections.push_back(line.pointAt((*oc).ta));
+ }
+ } catch (Geom::InfiniteSolutions) {
+ // Shouldn't happen as we have already taken care of horizontal/vertical guides.
+ std::cerr << "CanvasItemGuideLine::render: Error: Infinite intersections." << std::endl;
+ }
+ }
+
+ if (intersections.size() == 2) {
+ double const x0 = intersections[0].x();
+ double const x1 = intersections[1].x();
+ double const y0 = intersections[0].y();
+ double const y1 = intersections[1].y();
+ ctx->move_to(x0, y0);
+ ctx->line_to(x1, y1);
+ }
+ }
+ ctx->stroke();
+
+ ctx->restore();
+}
+
+void CanvasItemGuideLine::hide()
+{
+ CanvasItem::hide();
+ _origin_ctrl->hide();
+}
+
+void CanvasItemGuideLine::show()
+{
+ CanvasItem::show();
+ _origin_ctrl->show();
+}
+
+void CanvasItemGuideLine::set_stroke(guint32 color)
+{
+ // Make sure the fill of the control is the same as the stroke
+ // of the guide-line:
+ _origin_ctrl->set_fill(color);
+ CanvasItem::set_stroke(color);
+}
+
+void CanvasItemGuideLine::set_label(Glib::ustring const & label)
+{
+ if (_label != label) {
+ _label = label;
+ request_update();
+ }
+}
+
+void CanvasItemGuideLine::set_locked(bool locked)
+{
+ if (_locked != locked) {
+ _locked = locked;
+ if (_locked) {
+ _origin_ctrl->set_shape(CANVAS_ITEM_CTRL_SHAPE_CROSS);
+ _origin_ctrl->set_stroke(CONTROL_LOCKED_COLOR);
+ _origin_ctrl->set_fill(0x00000000); // no fill
+ } else {
+ _origin_ctrl->set_shape(CANVAS_ITEM_CTRL_SHAPE_CIRCLE);
+ _origin_ctrl->set_stroke(0x00000000); // no stroke
+ _origin_ctrl->set_fill(_stroke); // fill the control with this guide's color
+ }
+ }
+}
+
+//===============================================================================================
+
+/**
+ * @brief Create a handle ("dot") along a guide line
+ * @param group - the associated canvas item group
+ * @param pos - position
+ * @param line - pointer to the corresponding guide line
+ */
+CanvasItemGuideHandle::CanvasItemGuideHandle(CanvasItemGroup *group,
+ Geom::Point const &pos,
+ CanvasItemGuideLine* line)
+ : CanvasItemCtrl(group, CANVAS_ITEM_CTRL_SHAPE_CIRCLE, pos)
+ , _my_line(line) // Save a pointer to our guide line
+{
+}
+
+/**
+ * Return the radius of the handle dot
+ */
+double CanvasItemGuideHandle::radius() const
+{
+ return 0.5 * static_cast<double>(_width); // radius is half the width
+}
+
+/**
+ * Update the size of the handle based on the index from Preferences
+ */
+void CanvasItemGuideHandle::set_size_via_index(int index)
+{
+ double const r = static_cast<double>(index) * SCALE;
+ unsigned long const rounded_diameter = std::lround(r * 2.0); // diameter is twice the radius
+ unsigned long size = rounded_diameter | 0x1; // make sure the size is always odd
+ if (size < MINIMUM_SIZE) {
+ size = MINIMUM_SIZE;
+ }
+ if (_width != size) {
+ _width = size;
+ _height = size;
+ _built = false;
+ request_update();
+ _my_line->request_update();
+ }
+}
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-guideline.h b/src/display/control/canvas-item-guideline.h
new file mode 100644
index 0000000..af22e4e
--- /dev/null
+++ b/src/display/control/canvas-item-guideline.h
@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_GUIDELINE_H
+#define SEEN_CANVAS_ITEM_GUIDELINE_H
+
+/**
+ * A class to represent a control guide line.
+ */
+
+/*
+ * Authors:
+ * Tavmjong Bah - Rewrite of SPGuideLine
+ * Rafael Siejakowski - Tweaks to handle appearance
+ *
+ * Copyright (C) 2020-2022 the Authors.
+ *
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/ustring.h>
+
+#include <2geom/point.h>
+#include <2geom/transforms.h>
+
+#include "canvas-item.h"
+#include "canvas-item-ctrl.h"
+
+namespace Inkscape {
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+class CanvasItemGuideHandle; // A handle ("dot") serving as draggable origin control
+
+class CanvasItemGuideLine : public CanvasItem {
+
+public:
+ CanvasItemGuideLine(CanvasItemGroup *group, Glib::ustring label,
+ Geom::Point const &origin, Geom::Point const &normal);
+ ~CanvasItemGuideLine() override;
+
+ // Geometry
+ void set_origin(Geom::Point const &origin);
+ void set_normal(Geom::Point const &normal);
+ bool is_horizontal() const { return (_normal.x() == 0.0); }
+ bool is_vertical() const { return (_normal.y() == 0.0); }
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p);
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+ // Properties
+ void hide() override;
+ void show() override;
+ void set_stroke(guint32 color) final;
+ void set_label(Glib::ustring const & label);
+ void set_locked(bool locked);
+ void set_inverted(bool inverted);
+ void set_sensitive(bool sensitive) { _sensitive = sensitive; }
+
+ // Getters
+ CanvasItemGuideHandle* dot() const;
+
+protected:
+ Geom::Point _origin;
+ Geom::Point _normal = Geom::Point(0,1);
+ Glib::ustring _label;
+ bool _locked = true; // Flipped in constructor to trigger init of _origin_ctrl.
+ bool _inverted = false;
+ bool _sensitive = false;
+ std::unique_ptr<CanvasItemGuideHandle> _origin_ctrl;
+
+private:
+ inline static guint32 const CONTROL_LOCKED_COLOR = 0x00000080; // RGBA black semitranslucent
+ inline static double const LABEL_SEP = 2.0; // Distance between the label and the origin control
+};
+
+
+class CanvasItemGuideHandle : public CanvasItemCtrl {
+
+public:
+ CanvasItemGuideHandle(CanvasItemGroup *group, Geom::Point const &pos, CanvasItemGuideLine *line);
+ double radius() const;
+ void set_size_via_index(int index) final;
+
+private:
+ CanvasItemGuideLine *_my_line; // The guide line we belong to
+
+ // static data
+ inline static double const SCALE = 0.55; // handle size relative to an auto-smooth node
+ inline static unsigned const MINIMUM_SIZE = 7; // smallest handle size, must be an odd int
+};
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_GUIDELINE_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 :
diff --git a/src/display/control/canvas-item-quad.cpp b/src/display/control/canvas-item-quad.cpp
new file mode 100644
index 0000000..ccc7b2b
--- /dev/null
+++ b/src/display/control/canvas-item-quad.cpp
@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to represent a control quadrilateral. Used to highlight selected text.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCtrlQuadr
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-item-quad.h"
+
+#include "color.h" // SP_RGBA_x_F
+
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+/**
+ * Create an null control quad.
+ */
+CanvasItemQuad::CanvasItemQuad(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemQuad:Null";
+ _pickable = false; // For now, nobody gets events from this class!
+}
+
+/**
+ * Create a control quad. Point are in document coordinates.
+ */
+CanvasItemQuad::CanvasItemQuad(CanvasItemGroup *group,
+ Geom::Point const &p0, Geom::Point const &p1,
+ Geom::Point const &p2, Geom::Point const &p3)
+ : CanvasItem(group)
+ , _p0(p0)
+ , _p1(p1)
+ , _p2(p2)
+ , _p3(p3)
+{
+ _name = "CanvasItemQuad";
+ _pickable = false; // For now, nobody gets events from this class!
+
+ request_update();
+}
+
+/**
+ * Set a control quad. Points are in document coordinates.
+ */
+void CanvasItemQuad::set_coords(Geom::Point const &p0, Geom::Point const &p1, Geom::Point const &p2, Geom::Point const &p3)
+{
+ std::cout << "Canvas_ItemQuad::set_cords: " << p0 << ", " << p1 << ", " << p2 << ", " << p3 << std::endl;
+ _p0 = p0;
+ _p1 = p1;
+ _p2 = p2;
+ _p3 = p3;
+
+ request_update();
+}
+
+/**
+ * Returns distance between point in canvas units and nearest point on quad.
+ */
+double CanvasItemQuad::closest_distance_to(Geom::Point const &p)
+{
+ double d = Geom::infinity();
+ std::cerr << "CanvasItemQuad::closest_distance_to: Not implemented!" << std::endl;
+ return d;
+}
+
+/**
+ * Returns true if point p (in canvas units) is within tolerance (canvas units) distance of quad.
+ */
+bool CanvasItemQuad::contains(Geom::Point const &p, double tolerance)
+{
+ if (tolerance != 0) {
+ std::cerr << "CanvasItemQuad::contains: Non-zero tolerance not implemented!" << std::endl;
+ }
+
+ Geom::Point p0 = _p0 * _affine;
+ Geom::Point p1 = _p1 * _affine;
+ Geom::Point p2 = _p2 * _affine;
+ Geom::Point p3 = _p3 * _affine;
+
+ // From 2geom rotated-rect.cpp
+ return
+ Geom::cross(p1 - p0, p - p0) >= 0 &&
+ Geom::cross(p2 - p1, p - p1) >= 0 &&
+ Geom::cross(p3 - p2, p - p2) >= 0 &&
+ Geom::cross(p0 - p3, p - p3) >= 0;
+}
+
+/**
+ * Update and redraw control quad.
+ */
+void CanvasItemQuad::update(Geom::Affine const &affine)
+{
+ if (_affine == affine && !_need_update) {
+ // Nothing to do.
+ return;
+ }
+
+ if (_p0 == _p1 ||
+ _p1 == _p2 ||
+ _p2 == _p3 ||
+ _p3 == _p0) {
+ return; // Not quad or not initialized.
+ }
+
+ // Queue redraw of old area (erase previous content).
+ request_redraw(); // This is actually never useful as quads are always deleted
+ // and recreated when a node is moved! But keep it in case we
+ // change that. CHECK
+ // Get new bounds
+ _affine = affine;
+
+ Geom::Rect bounds;
+ bounds.expandTo(_p0);
+ bounds.expandTo(_p1);
+ bounds.expandTo(_p2);
+ bounds.expandTo(_p3);
+ bounds *= _affine; // Document to canvas.
+ bounds.expandBy(2); // Room for anti-aliasing effects.
+ _bounds = bounds;
+
+ // Queue redraw of new area
+ request_redraw();
+
+ _need_update = false;
+}
+
+/**
+ * Render quad to screen via Cairo.
+ */
+void CanvasItemQuad::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (!buf) {
+ std::cerr << "CanvasItemQuad::Render: No buffer!" << std::endl;
+ return;
+ }
+
+ if (_p0 == _p1 ||
+ _p1 == _p2 ||
+ _p2 == _p3 ||
+ _p3 == _p0) {
+ return; // Not quad or not initialized.
+ }
+
+ if (!_visible) {
+ // Hidden
+ return;
+ }
+
+ // Document to canvas
+ Geom::Point p0 = _p0 * _affine;
+ Geom::Point p1 = _p1 * _affine;
+ Geom::Point p2 = _p2 * _affine;
+ Geom::Point p3 = _p3 * _affine;
+
+ // Canvas to screen
+ p0 *= Geom::Translate(-buf->rect.min());
+ p1 *= Geom::Translate(-buf->rect.min());
+ p2 *= Geom::Translate(-buf->rect.min());
+ p3 *= Geom::Translate(-buf->rect.min());
+
+ buf->cr->save();
+
+ buf->cr->begin_new_path();
+
+ buf->cr->move_to(p0.x(), p0.y());
+ buf->cr->line_to(p1.x(), p1.y());
+ buf->cr->line_to(p2.x(), p2.y());
+ buf->cr->line_to(p3.x(), p3.y());
+ buf->cr->close_path();
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_fill), SP_RGBA32_G_F(_fill),
+ SP_RGBA32_B_F(_fill), SP_RGBA32_A_F(_fill));
+ buf->cr->fill();
+
+ // Uncomment to show bounds
+ // Geom::Rect bounds = _bounds;
+ // bounds.expandBy(-1);
+ // bounds -= buf->rect.min();
+ // buf->cr->set_source_rgba(1.0, 0.0, 0.0, 1.0);
+ // buf->cr->rectangle(bounds.min().x(), bounds.min().y(), bounds.width(), bounds.height());
+ // buf->cr->stroke();
+
+ buf->cr->restore();
+}
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-quad.h b/src/display/control/canvas-item-quad.h
new file mode 100644
index 0000000..d7945de
--- /dev/null
+++ b/src/display/control/canvas-item-quad.h
@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_QUAD_H
+#define SEEN_CANVAS_ITEM_QUAD_H
+
+/**
+ * A class to represent a control quadrilateral. Used to highlight selected text.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCtrlQuadr
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <2geom/point.h>
+#include <2geom/transforms.h>
+
+#include "canvas-item.h"
+
+namespace Inkscape {
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemQuad : public CanvasItem {
+
+public:
+ CanvasItemQuad(CanvasItemGroup *group);
+ CanvasItemQuad(CanvasItemGroup *group, Geom::Point const &p0, Geom::Point const &p1,
+ Geom::Point const &p2, Geom::Point const &p3);
+
+ // Geometry
+ void set_coords(Geom::Point const &p0, Geom::Point const &p1, Geom::Point const &p2, Geom::Point const &p3);
+
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p); // Maybe not needed
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+protected:
+ Geom::Point _p0;
+ Geom::Point _p1;
+ Geom::Point _p2;
+ Geom::Point _p3;
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_QUAD_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 :
diff --git a/src/display/control/canvas-item-rect.cpp b/src/display/control/canvas-item-rect.cpp
new file mode 100644
index 0000000..137cbf1
--- /dev/null
+++ b/src/display/control/canvas-item-rect.cpp
@@ -0,0 +1,353 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to represent a control rectangle. Used for rubberband selector, page outline, etc.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of CtrlRect
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <cairo/cairo.h>
+
+#include "canvas-item-rect.h"
+#include "display/cairo-utils.h"
+
+#include "color.h" // SP_RGBA_x_F
+#include "inkscape.h" //
+#include "ui/widget/canvas.h"
+#include "display/cairo-utils.h" // Checkerboard background.
+
+namespace Inkscape {
+
+/**
+ * Create an null control rect.
+ */
+CanvasItemRect::CanvasItemRect(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemRect:Null";
+ _pickable = false; // For now, nobody gets events from this class!
+}
+
+/**
+ * Create a control rect. Point are in document coordinates.
+ */
+CanvasItemRect::CanvasItemRect(CanvasItemGroup *group, Geom::Rect const &rect)
+ : CanvasItem(group)
+ , _rect(rect)
+{
+ _name = "CanvasItemRect";
+ _pickable = false; // For now, nobody gets events from this class!
+ request_update();
+}
+
+/**
+ * Set a control rect. Points are in document coordinates.
+ */
+void CanvasItemRect::set_rect(Geom::Rect const &rect)
+{
+ _rect = rect;
+ request_update();
+}
+
+/**
+ * Returns distance between point in canvas units and nearest point in rect (zero if inside rect).
+ * Only valid if canvas is not rotated. (A rotated Geom::Rect yields a new axis-aligned Geom::Rect
+ * that contains the original rectangle; not a rotated rectangle.)
+ */
+double CanvasItemRect::closest_distance_to(Geom::Point const &p)
+{
+ if (_affine.isNonzeroRotation()) {
+ std::cerr << "CanvasItemRect::closest_distance_to: Affine includes rotation!" << std::endl;
+ }
+
+ Geom::Rect rect = _rect;
+ rect *= _affine; // Convert from document to canvas coordinates. (TODO Cache this.)
+ return Geom::distance(p, rect);
+}
+
+/**
+ * Returns true if point p (in canvas units) is within tolerance (canvas units) distance of rect.
+ * Non-zero tolerance not implemented! Is valid for a rotated canvas.
+ */
+bool CanvasItemRect::contains(Geom::Point const &p, double tolerance)
+{
+ if (tolerance != 0) {
+ std::cerr << "CanvasItemRect::contains: Non-zero tolerance not implemented!" << std::endl;
+ }
+
+ Geom::Point p0 = _rect.corner(0) * _affine;
+ Geom::Point p1 = _rect.corner(1) * _affine;
+ Geom::Point p2 = _rect.corner(2) * _affine;
+ Geom::Point p3 = _rect.corner(3) * _affine;
+
+ // From 2geom rotated-rect.cpp
+ return
+ Geom::cross(p1 - p0, p - p0) >= 0 &&
+ Geom::cross(p2 - p1, p - p1) >= 0 &&
+ Geom::cross(p3 - p2, p - p2) >= 0 &&
+ Geom::cross(p0 - p3, p - p3) >= 0;
+}
+
+/**
+ * Update and redraw control rect.
+ */
+void CanvasItemRect::update(Geom::Affine const &affine)
+{
+ if (_affine == affine && !_need_update) {
+ // Nothing to do.
+ return;
+ }
+
+ if (_rect.area() == 0) {
+ return; // Nothing to show
+ }
+
+ // Queue redraw of old area (erase previous content).
+ request_redraw();
+
+ // Get new bounds
+ _affine = affine;
+
+ // Enlarge bbox by twice shadow size (to allow for shadow on any side with a 45deg rotation).
+ _bounds = _rect;
+ // note: add shadow size before applying transformation, since get_shadow_size accounts for scale
+ _bounds.expandBy(2 * get_shadow_size());
+ _bounds *= _affine;
+ _bounds.expandBy(2); // Room for stroke.
+
+ // Queue redraw of new area
+ request_redraw();
+
+ _need_update = false;
+}
+
+/**
+ * Render rect to screen via Cairo.
+ */
+void CanvasItemRect::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (!buf) {
+ std::cerr << "CanvasItemRect::Render: No buffer!" << std::endl;
+ return;
+ }
+
+ if (!_bounds.intersects(buf->rect)) {
+ return; // Rectangle not inside buffer rectangle.
+ }
+
+ if (!_visible) {
+ // Hidden
+ return;
+ }
+
+ // Geom::Rect is an axis-aligned rectangle. We need to rotate it if the canvas is rotated!
+
+ // Get canvas rotation (scale is isotropic).
+ double rotation = atan2(_affine[1], _affine[0]);
+
+ // Are we axis aligned?
+ double mod_rot = fmod(rotation * M_2_PI, 1);
+ bool axis_aligned = Geom::are_near(mod_rot, 0) || Geom::are_near(mod_rot, 1.0);
+
+ // Get the points we need transformed into window coordinates.
+ Geom::Point rect_transformed[4];
+ for (unsigned int i = 0; i < 4; ++i) {
+ rect_transformed[i] = _rect.corner(i) * _affine;
+ }
+
+ auto rect = _rect;
+
+ using Geom::X;
+ using Geom::Y;
+
+ if (axis_aligned) {
+ auto temp = _rect * _affine;
+ auto min = temp.min();
+ auto max = temp.max();
+ auto pixgrid = Geom::Rect(
+ Geom::Point(floor(min[X]) + 0.5, floor(min[Y]) + 0.5),
+ Geom::Point(floor(max[X]) + 0.5, floor(max[Y]) + 0.5));
+ rect = pixgrid * _affine.inverse();
+ }
+
+ buf->cr->save();
+ buf->cr->translate(-buf->rect.left(), -buf->rect.top());
+
+ if (_inverted) {
+ // buf->cr->set_operator(Cairo::OPERATOR_XOR); // Blend mode operators do not have C++ bindings!
+ cairo_set_operator(buf->cr->cobj(), CAIRO_OPERATOR_DIFFERENCE);
+ }
+
+ // fill background?
+ if (_background && !buf->outline_overlay_pass) {
+ buf->cr->save();
+ Cairo::Matrix m(_affine[0], _affine[1], _affine[2], _affine[3], _affine[4], _affine[5]);
+ buf->cr->transform(m);
+ buf->cr->rectangle(rect.corner(0)[X], rect.corner(0)[Y], rect.width(), rect.height());
+ // counter fill scaling (necessary for checkerboard pattern)
+ _background->set_matrix(m);
+ buf->cr->set_source(_background);
+ buf->cr->fill();
+ buf->cr->restore();
+ }
+
+ cairo_pattern_t *pattern = _canvas->get_background_pattern()->cobj();
+ guint32 backcolor = ink_cairo_pattern_get_argb32(pattern);
+ EXTRACT_ARGB32(backcolor, ab,rb,gb,bb)
+
+ // Draw shadow first. Shadow extends under rectangle to reduce aliasing effects.
+ if (_shadow_width > 0 && !_dashed) {
+ // there's only one UI knob to adjust border and shadow color, so instead of using border color
+ // transparency as is, it is boosted by this function, since shadow attenuates it
+ const auto a = (exp(-3 * SP_RGBA32_A_F(_shadow_color)) - 1) / (exp(-3) - 1);
+ buf->cr->save();
+
+ auto affine = _affine;
+ if (auto desktop = _canvas->get_desktop()) {
+ rect *= desktop->doc2dt();
+ affine = desktop->doc2dt() * affine;
+ }
+ Cairo::Matrix m(affine[0], affine[1], affine[2], affine[3], affine[4], affine[5]);
+ buf->cr->transform(m);
+ ink_cairo_draw_drop_shadow(buf->cr, rect, get_shadow_size(), _shadow_color, a);
+ buf->cr->restore();
+ }
+
+ // Setup rectangle path
+ if (axis_aligned) {
+
+ // Snap to pixel grid
+ Geom::Rect outline( _rect.min() * _affine, _rect.max() * _affine);
+ buf->cr->rectangle(floor(outline.min()[X])+0.5,
+ floor(outline.min()[Y])+0.5,
+ floor(outline.max()[X]) - floor(outline.min()[X]),
+ floor(outline.max()[Y]) - floor(outline.min()[Y]));
+ } else {
+
+ // Rotated
+ buf->cr->move_to(rect_transformed[0][X], rect_transformed[0][Y] );
+ buf->cr->line_to(rect_transformed[1][X], rect_transformed[1][Y] );
+ buf->cr->line_to(rect_transformed[2][X], rect_transformed[2][Y] );
+ buf->cr->line_to(rect_transformed[3][X], rect_transformed[3][Y] );
+ buf->cr->close_path();
+ }
+ static std::valarray<double> dashes = {4.0, 4.0};
+ if (_dashed) {
+ buf->cr->set_dash(dashes, -0.5);
+ }
+ // Draw border (stroke).
+ buf->cr->set_line_width(1);
+ // we maybe have painted the background, back to "normal" compositing
+
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_stroke), SP_RGBA32_G_F(_stroke),
+ SP_RGBA32_B_F(_stroke), SP_RGBA32_A_F(_stroke));
+ buf->cr->stroke_preserve();
+
+ // Highlight the border by drawing it in _shadow_color.
+ if (_shadow_width == 1 && _dashed) {
+ buf->cr->set_dash(dashes, 3.5); // Dash offset by dash length.
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_shadow_color), SP_RGBA32_G_F(_shadow_color),
+ SP_RGBA32_B_F(_shadow_color), SP_RGBA32_A_F(_shadow_color));
+ buf->cr->stroke_preserve();
+ }
+
+ buf->cr->begin_new_path(); // Clear path or get weird artifacts.
+
+ // Uncomment to show bounds
+ // Geom::Rect bounds = _bounds;
+ // bounds.expandBy(-1);
+ // bounds -= buf->rect.min();
+ // buf->cr->set_source_rgba(1.0, 0.0, _shadow_width / 3.0, 1.0);
+ // buf->cr->rectangle(bounds.min().x(), bounds.min().y(), bounds.width(), bounds.height());
+ // buf->cr->stroke();
+
+ buf->cr->restore();
+}
+
+void CanvasItemRect::set_dashed(bool dashed)
+{
+ if (_dashed != dashed) {
+ _dashed = dashed;
+ request_redraw();
+ }
+}
+
+void CanvasItemRect::set_inverted(bool inverted)
+{
+ if (_inverted != inverted) {
+ _inverted = inverted;
+ request_redraw();
+ }
+}
+
+void CanvasItemRect::set_shadow(guint32 color, int width)
+{
+ if (_shadow_color != color || _shadow_width != width) {
+ _shadow_color = color;
+ _shadow_width = width;
+ request_redraw();
+ }
+}
+
+void CanvasItemRect::set_background(guint32 background) {
+ _set_background(Cairo::SolidPattern::create_rgba(SP_RGBA32_R_F(background), SP_RGBA32_G_F(background), SP_RGBA32_B_F(background), SP_RGBA32_A_F(background)));
+}
+
+void CanvasItemRect::_set_background(Cairo::RefPtr<Cairo::Pattern> background) {
+ if (_background != background) {
+ _background = background;
+ request_redraw();
+ }
+}
+
+double CanvasItemRect::get_scale() const {
+ return sqrt(_affine[0] * _affine[0] + _affine[1] * _affine[1]);
+}
+
+double CanvasItemRect::get_shadow_size() const {
+ // gradient drop shadow needs much more room than solid one, so inflating the size;
+ // fudge factor of 6 used to make sizes baked in svg documents work as steps:
+ // typical value of 2 will work out to 12 pixels which is a narrow shadow (b/c of exponential fall of)
+ auto size = _shadow_width * 6;
+ if (size < 0) {
+ size = 0;
+ }
+ else if (size > 120) {
+ // arbitrarily selected max size, so Cairo gradient doesn't blow up if document has bogus shadow values
+ size = 120;
+ }
+ auto scale = get_scale();
+
+ // calculate space for gradient shadow; if divided by 'scale' it would be zoom independent (fixed in size);
+ // if 'scale' is not used, drop shadow will be getting smaller with document zoom;
+ // here hybrid approach is used: "unscaling" with square root of scale allows shadows to diminish
+ // more slowly at small zoom levels (so it's still perceptible) and grow more slowly at high mag (where it doesn't matter, b/c it's typically off-screen)
+ return size / (scale > 0 ? sqrt(scale) : 1);
+}
+
+void CanvasItemRect::set_background_checkerboard(guint32 rgba, bool use_alpha) {
+ auto pattern = ink_cairo_pattern_create_checkerboard(rgba, use_alpha);
+ auto background = Cairo::RefPtr<Cairo::Pattern>(new Cairo::Pattern(pattern));
+ _set_background(background);
+}
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-rect.h b/src/display/control/canvas-item-rect.h
new file mode 100644
index 0000000..0c69d43
--- /dev/null
+++ b/src/display/control/canvas-item-rect.h
@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_RECT_H
+#define SEEN_CANVAS_ITEM_RECT_H
+
+/**
+ * A class to represent a control rectangle. Used for rubberband selector, page outline, etc.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of CtrlRect
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <memory>
+#include <2geom/path.h>
+
+#include "canvas-item.h"
+
+namespace Inkscape {
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemRect : public CanvasItem {
+
+public:
+ CanvasItemRect(CanvasItemGroup *group);
+ CanvasItemRect(CanvasItemGroup *group, Geom::Rect const &rect);
+
+ // Geometry
+ void set_rect(Geom::Rect const &rect);
+
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p); // Maybe not needed
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+ // Properties
+ void set_dashed(bool dash = true);
+ void set_inverted(bool inverted = false);
+ void set_shadow(guint32 color, int width);
+ void set_background(guint32 background);
+ void set_background_checkerboard(guint32 rgba, bool use_alpha);
+
+protected:
+ void _set_background(Cairo::RefPtr<Cairo::Pattern> background);
+ double get_shadow_size() const;
+ double get_scale() const;
+
+ Geom::Rect _rect;
+ bool _dashed = false;
+ bool _inverted = false;
+ int _shadow_width = 0;
+ guint32 _shadow_color = 0x00000000;
+ Cairo::RefPtr<Cairo::Pattern> _background; // optional background
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_RECT_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 :
diff --git a/src/display/control/canvas-item-rotate.cpp b/src/display/control/canvas-item-rotate.cpp
new file mode 100644
index 0000000..a013b65
--- /dev/null
+++ b/src/display/control/canvas-item-rotate.cpp
@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class for previewing a canvas rotation.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasRotate.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <cairomm/cairomm.h>
+#include <gdkmm/event.h>
+
+#include "canvas-item-rotate.h"
+
+#include "color.h" // SP_RGBA_x_F
+#include "desktop.h"
+#include "inkscape.h"
+
+#include "display/cairo-utils.h" // Copy Cairo surface.
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+/**
+ * Create an null control rotate.
+ */
+CanvasItemRotate::CanvasItemRotate(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemRotate";
+ _pickable = true; // We need the events!
+ _bounds = Geom::Rect(-Geom::infinity(), -Geom::infinity(), Geom::infinity(), Geom::infinity());
+}
+
+
+/**
+ * Returns distance between point in canvas units and nearest point on rotate.
+ */
+double CanvasItemRotate::closest_distance_to(Geom::Point const &p)
+{
+ double d = Geom::infinity();
+ std::cerr << "CanvasItemRotate::closest_distance_to: Not implemented!" << std::endl;
+ return d;
+}
+
+/**
+ * Returns true if point p (in canvas units) is within tolerance (canvas units) distance of rotate.
+ */
+bool CanvasItemRotate::contains(Geom::Point const &p, double tolerance)
+{
+ return true; // We're always picked!
+}
+
+/**
+ * Update and redraw control rotate.
+ */
+void CanvasItemRotate::update(Geom::Affine const &affine)
+{
+ _affine = affine;
+ request_redraw();
+}
+
+/**
+ * Render rotate to screen via Cairo.
+ */
+void CanvasItemRotate::render(Inkscape::CanvasItemBuffer *buf)
+{
+ return; // We do no proper rendering!
+}
+
+/**
+ * Start
+ */
+void CanvasItemRotate::start(SPDesktop *desktop)
+{
+ _desktop = desktop;
+
+ _current_angle = 0.0;
+
+ _surface_copy = ink_cairo_surface_copy(_canvas->get_backing_store());
+}
+
+/**
+ * Render to widget.
+ */
+void CanvasItemRotate::paint()
+{
+ auto background = _canvas->get_backing_store();
+
+ if (!background) {
+ std::cerr << "CanvasItemRotate::paint(): No background!" << std::endl;
+ return;
+ }
+
+ double width = background->get_width();
+ double height = background->get_height();
+
+ // Draw rotated canvas.
+ auto context = Cairo::Context::create(background);
+ context->set_operator(Cairo::OPERATOR_SOURCE);
+ context->translate(width/2.0, height/2.0);
+ context->rotate(Geom::rad_from_deg(-_current_angle));
+ context->translate(-width/2.0, -height/2.0);
+ context->set_source(_surface_copy, 0, 0);
+ context->paint();
+
+ _canvas->queue_draw();
+}
+
+/**
+ * Handle events.
+ */
+bool CanvasItemRotate::handle_event(GdkEvent *event)
+{
+ // Get geometry
+ Geom::Rect viewbox = _canvas->get_area_world();
+ _center = viewbox.midpoint();
+
+ switch (event->type) {
+ case GDK_MOTION_NOTIFY:
+ {
+ Geom::Point cursor( event->motion.x, event->motion.y );
+
+ // Both cursor and center are in window coordinates
+ Geom::Point rcursor( cursor - _center );
+ double angle = Geom::deg_from_rad( Geom::atan2(rcursor) );
+
+
+ // Set start angle
+ if (_start_angle < -360) {
+ _start_angle = angle;
+ }
+
+ const double rotation_snap = 15;
+
+ double delta_angle = _start_angle - angle;
+
+ if (event->motion.state & GDK_SHIFT_MASK &&
+ event->motion.state & GDK_CONTROL_MASK) {
+ delta_angle = 0;
+ } else if (event->motion.state & GDK_SHIFT_MASK) {
+ delta_angle = round(delta_angle/rotation_snap) * rotation_snap;
+ } else if (event->motion.state & GDK_CONTROL_MASK) {
+ // ?
+ } else if (event->motion.state & GDK_MOD1_MASK) {
+ // Decimal raw angle
+ } else {
+ delta_angle = floor(delta_angle);
+ }
+
+ _current_angle = delta_angle;
+
+ // Correct line for snapping of angle
+ double distance = rcursor.length();
+ _cursor = Geom::Point::polar( Geom::rad_from_deg(angle), distance );
+
+ // Update screen
+ paint();
+ break;
+ }
+ case GDK_BUTTON_RELEASE:
+ {
+ // Rotate the actual canvas
+ SPDesktop *desktop = SP_ACTIVE_DESKTOP; // FIXME..
+ desktop->rotate_relative_center_point (desktop->w2d(_center),
+ (desktop->w2d().det() > 0 ? -1 : 1) *
+ Geom::rad_from_deg(_current_angle) );
+
+ // We're done
+ ungrab();
+ hide();
+
+ _start_angle = -1000;
+ break;
+ }
+ case GDK_KEY_PRESS:
+ // std::cout << " Key press: " << std::endl;
+ break;
+ case GDK_KEY_RELEASE:
+ // std::cout << " Key release: " << std::endl;
+ break;
+ default:
+ // ui_dump_event (event, "sp_canvas_rotate_event: unwanted event: ");
+ break;
+ }
+
+ if (event->type == GDK_KEY_PRESS) return false; // Why?
+
+ // Don't emit event signal!
+
+ return true;
+}
+
+} // namespace Inkscape
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-rotate.h b/src/display/control/canvas-item-rotate.h
new file mode 100644
index 0000000..a2aebd5
--- /dev/null
+++ b/src/display/control/canvas-item-rotate.h
@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_ROTATE_H
+#define SEEN_CANVAS_ITEM_ROTATE_H
+
+/**
+ * A class for previewing a canvas rotation.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of RotateCanvasItem.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <2geom/point.h>
+#include <2geom/transforms.h>
+
+#include "canvas-item.h"
+
+class SPDesktop;
+
+namespace Inkscape {
+
+class CanvasRotate;
+
+namespace UI::Widget {
+class Canvas;
+}
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemRotate : public CanvasItem {
+
+public:
+ CanvasItemRotate(CanvasItemGroup *group);
+
+ // Geometry
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p); // Maybe not needed
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+ // Events
+ bool handle_event(GdkEvent *event) override;
+ void start(SPDesktop *desktop);
+ void paint();
+
+
+protected:
+ SPDesktop *_desktop = nullptr;
+ Geom::Point _center; // Center of screen.
+ Geom::Point _cursor; // Position of cursor relative to center (after angle snapping).
+ double _current_angle = 0.0; // Rotation in degrees.
+ double _start_angle = -1000; // Initial angle, determined by cursor position.
+ Cairo::RefPtr<Cairo::ImageSurface> _surface_copy; // Copy of original surface.
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_ROTATE_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 :
diff --git a/src/display/control/canvas-item-text.cpp b/src/display/control/canvas-item-text.cpp
new file mode 100644
index 0000000..f4a6801
--- /dev/null
+++ b/src/display/control/canvas-item-text.cpp
@@ -0,0 +1,317 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A class to represent a control textrilateral. Used to highlight selected text.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCtrlTextr
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-item-text.h"
+
+#include <cmath>
+#include <utility> // std::move
+#include <glibmm/i18n.h>
+
+#include "color.h" // SP_RGBA_x_F
+
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+/**
+ * Create an null control text.
+ */
+CanvasItemText::CanvasItemText(CanvasItemGroup *group)
+ : CanvasItem(group)
+{
+ _name = "CanvasItemText";
+ _pickable = false; // Text is never pickable.
+ _fill = 0x33337fff; // Override CanvasItem default.
+}
+
+/**
+ * Create a control text. Point are in document coordinates.
+ */
+CanvasItemText::CanvasItemText(CanvasItemGroup *group, Geom::Point const &p, Glib::ustring text)
+ : CanvasItem(group)
+ , _p(p)
+ , _text(std::move(text))
+{
+ _name = "CanvasItemText";
+ _pickable = false; // Text is never pickable.
+ _fill = 0x33337fff; // Override CanvasItem default.
+
+ request_update();
+}
+
+/**
+ * Set a text position. Position is in document coordinates.
+ */
+void CanvasItemText::set_coord(Geom::Point const &p)
+{
+ _p = p;
+
+ request_update();
+}
+
+/**
+ * Set a text position. Position is in document coordinates.
+ */
+void CanvasItemText::set_bg_radius(double const &rad)
+{
+ _bg_rad = rad;
+
+ request_update();
+}
+
+/**
+ * Returns distance between point in canvas units and nearest point on text.
+ */
+double CanvasItemText::closest_distance_to(Geom::Point const &p)
+{
+ double d = Geom::infinity();
+ std::cerr << "CanvasItemText::closest_distance_to: Not implemented!" << std::endl;
+ return d;
+}
+
+/**
+ * Returns true if point p (in canvas units) is within tolerance (canvas units) distance of text.
+ */
+bool CanvasItemText::contains(Geom::Point const &p, double tolerance)
+{
+ return false; // We never select text.
+}
+
+/**
+ * Update and redraw control text.
+ */
+void CanvasItemText::update(Geom::Affine const &affine)
+{
+ if (_affine == affine && !_need_update) {
+ // Nothing to do.
+ return;
+ }
+
+ // Queue redraw of old area (erase previous content).
+ request_redraw();
+
+ // Get new bounds
+ _affine = affine;
+ Geom::Point p = _p * _affine;
+
+ // Measure text size
+ auto surface = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, 1, 1);
+ auto context = Cairo::Context::create(surface);
+ context->select_font_face(_fontname, Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_NORMAL);
+ context->set_font_size(_fontsize);
+ context->get_text_extents(_text, _text_size);
+
+ if (_fixed_line) {
+ // TRANSLATORS: This is a set of letters to test for font accender and decenders.
+ context->get_text_extents(_("lg1p$"), _text_extent);
+ } else {
+ _text_extent = _text_size;
+ }
+
+ // See note at bottom.
+ _bounds = Geom::Rect::from_xywh(0, 0,
+ _text_size.x_advance + (_border * 2),
+ _text_extent.height + (_border * 2));
+
+ // Offset relative to requested point
+ double offset_x = -(_anchor_position.x() * _bounds.width());
+ double offset_y = -(_anchor_position.y() * _bounds.height());
+ offset_x += p.x() + _adjust_offset.x();
+ offset_y += p.y() + _adjust_offset.y();
+ _bounds *= Geom::Translate(Geom::Point(int(offset_x), int(offset_y)));
+
+ // Pixel alignment of background. Avoid aliasing artifacts on redraw.
+ _bounds = _bounds.roundOutwards();
+
+ // Queue redraw of new area
+ request_redraw();
+
+ _need_update = false;
+}
+
+/**
+ * Render text to screen via Cairo.
+ */
+void CanvasItemText::render(Inkscape::CanvasItemBuffer *buf)
+{
+ if (!buf) {
+ std::cerr << "CanvasItemText::Render: No buffer!" << std::endl;
+ return;
+ }
+
+ if (!_visible) {
+ // Hidden
+ return;
+ }
+
+ buf->cr->save();
+
+ double x = _bounds.min().x() - buf->rect.min().x();
+ double y = _bounds.min().y() - buf->rect.min().y();
+
+ // Background
+ if (_use_background) {
+ if (_bg_rad == 0) {
+ buf->cr->rectangle(x, y, _bounds.width(), _bounds.height());
+ } else {
+ double smallest = std::min(_bounds.width(), _bounds.height());
+ double radius = _bg_rad * (smallest / 2);
+ buf->cr->arc(x + _bounds.width() - radius,
+ y + radius,
+ radius,
+ -M_PI_2,
+ 0);
+
+ buf->cr->arc(x + _bounds.width() - radius,
+ y + _bounds.height() - radius,
+ radius,
+ 0,
+ M_PI_2);
+
+ buf->cr->arc(x + radius, y + _bounds.height() - radius,
+ radius,
+ M_PI_2,
+ M_PI);
+
+ buf->cr->arc(x + radius,
+ y + radius,
+ radius,
+ M_PI,
+ 3*M_PI_2);
+ }
+ buf->cr->set_line_width(2);
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_background), SP_RGBA32_G_F(_background),
+ SP_RGBA32_B_F(_background), SP_RGBA32_A_F(_background));
+ buf->cr->fill();
+ }
+
+ // Center the text inside the draw background box
+ auto bx = x + _bounds.width()/2.0;
+ auto by = y + _bounds.height()/2.0;
+ buf->cr->move_to(int(bx - _text_size.x_bearing - _text_size.width/2.0),
+ int(by - _text_size.y_bearing - _text_extent.height/2.0));
+
+ buf->cr->select_font_face(_fontname, Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_NORMAL);
+ buf->cr->set_font_size(_fontsize);
+ buf->cr->text_path(_text);
+ buf->cr->set_source_rgba(SP_RGBA32_R_F(_fill), SP_RGBA32_G_F(_fill),
+ SP_RGBA32_B_F(_fill), SP_RGBA32_A_F(_fill));
+ buf->cr->fill();
+
+#ifdef CANVAS_ITEM_DEBUG
+ Geom::Rect bounds = _bounds;
+ bounds.expandBy(-1);
+ bounds -= buf->rect.min();
+ buf->cr->set_source_rgba(1.0, 0.0, 0.0, 1.0);
+ buf->cr->rectangle(bounds.min().x(), bounds.min().y(), bounds.width(), bounds.height());
+ buf->cr->stroke();
+#endif
+
+ buf->cr->restore();
+}
+
+void CanvasItemText::set_text(Glib::ustring const &text)
+{
+ if (_text != text) {
+ _text = text;
+ request_update(); // Might be larger than before!
+ }
+}
+
+void CanvasItemText::set_fontsize(double fontsize)
+{
+ if (_fontsize != fontsize) {
+ _fontsize = fontsize;
+ request_update(); // Might be larger than before!
+ }
+}
+
+void CanvasItemText::set_background(guint32 background)
+{
+ if (_background != background) {
+ _background = background;
+ request_redraw();
+ }
+ _use_background = true;
+}
+
+/**
+ * Set the anchor point, x and y between 0.0 and 1.0.
+ */
+void CanvasItemText::set_anchor(Geom::Point const &anchor_pt)
+{
+ if (_anchor_position != anchor_pt) {
+ _anchor_position = anchor_pt;
+ _canvas->request_update();
+ }
+}
+
+void CanvasItemText::set_adjust(Geom::Point const &adjust_pt)
+{
+ if (_adjust_offset != adjust_pt) {
+ _adjust_offset = adjust_pt;
+ _canvas->request_update();
+ }
+}
+
+void CanvasItemText::set_fixed_line(bool fixed_line)
+{
+ if (_fixed_line != fixed_line) {
+ _fixed_line = fixed_line;
+ _canvas->request_update();
+ }
+}
+
+} // namespace Inkscape
+
+/* FROM: http://lists.cairographics.org/archives/cairo-bugs/2009-March/003014.html
+ - Glyph surfaces: In most font rendering systems, glyph surfaces
+ have an origin at (0,0) and a bounding box that is typically
+ represented as (x_bearing,y_bearing,width,height). Depending on
+ which way y progresses in the system, y_bearing may typically be
+ negative (for systems similar to cairo, with origin at top left),
+ or be positive (in systems like PDF with origin at bottom left).
+ No matter which is the case, it is important to note that
+ (x_bearing,y_bearing) is the coordinates of top-left of the glyph
+ relative to the glyph origin. That is, for example:
+
+ Scaled-glyph space:
+
+ (x_bearing,y_bearing) <-- negative numbers
+ +----------------+
+ | . |
+ | . |
+ |......(0,0) <---|-- glyph origin
+ | |
+ | |
+ +----------------+
+ (width+x_bearing,height+y_bearing)
+
+ Note the similarity of the origin to the device space. That is
+ exactly how we use the device_offset to represent scaled glyphs:
+ to use the device-space origin as the glyph origin.
+*/
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item-text.h b/src/display/control/canvas-item-text.h
new file mode 100644
index 0000000..c5d5cff
--- /dev/null
+++ b/src/display/control/canvas-item-text.h
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_TEXT_H
+#define SEEN_CANVAS_ITEM_TEXT_H
+
+/**
+ * A class to represent on-screen text.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasText.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/ustring.h>
+
+#include <2geom/point.h>
+#include <2geom/transforms.h>
+
+#include "canvas-item.h"
+
+namespace Inkscape {
+
+namespace UI::Widget {
+class Canvas;
+}
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItemText : public CanvasItem {
+
+public:
+ CanvasItemText(CanvasItemGroup *group);
+ CanvasItemText(CanvasItemGroup *group, Geom::Point const &p, Glib::ustring text);
+
+ // Geometry
+ void set_coord(Geom::Point const &p);
+ void set_bg_radius(double const &rad);
+
+ void update(Geom::Affine const &affine) override;
+ double closest_distance_to(Geom::Point const &p); // Maybe not needed
+
+ // Selection
+ bool contains(Geom::Point const &p, double tolerance = 0) override;
+
+ // Display
+ void render(Inkscape::CanvasItemBuffer *buf) override;
+
+ // Properties
+ void set_text(Glib::ustring const &text);
+ void set_fontsize(double fontsize);
+ void set_background(guint32 background);
+ void set_anchor(Geom::Point const &anchor_pt);
+ void set_adjust(Geom::Point const &adjust_pt);
+ void set_fixed_line(bool fixed_line);
+
+protected:
+ Geom::Point _p; // Position of text (not box around text).
+ Cairo::TextExtents _text_extent;
+ Cairo::TextExtents _text_size;
+ Geom::Point _anchor_position;
+ Geom::Point _adjust_offset;
+ Glib::ustring _text;
+ std::string _fontname = "sans-serif";
+ double _fontsize = 10;
+ double _bg_rad = 0;
+ guint32 _background = 0x0000007f;
+ bool _use_background = false;
+ bool _fixed_line = false; // Correction for font heights
+ const double _border = 3; // Must be a const to allow alignment with other text boxes.
+};
+
+
+} // namespace Inkscape
+
+#endif // SEEN_CANVAS_ITEM_TEXT_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 :
diff --git a/src/display/control/canvas-item.cpp b/src/display/control/canvas-item.cpp
new file mode 100644
index 0000000..6670b19
--- /dev/null
+++ b/src/display/control/canvas-item.cpp
@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * Abstract base class for on-canvas control items.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasItem
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-item.h"
+
+#include "canvas-item-group.h"
+
+#include "ui/widget/canvas.h"
+
+namespace Inkscape {
+
+CanvasItem::CanvasItem(CanvasItemGroup *group)
+ : _name("CanvasItem")
+{
+ if (group) {
+ group->add(this);
+ _parent = group;
+ _canvas = group->get_canvas();
+ _affine = group->get_affine();
+ }
+}
+
+CanvasItem::~CanvasItem()
+{
+ if (_parent) {
+ _parent->remove(this, false); // remove() should not delete this or we'll double delete!
+ }
+
+ // Clear canvas of item.
+ request_redraw();
+
+ // Clear any pointers to this object in canvas.
+ _canvas->canvas_item_destructed(this);
+}
+
+bool CanvasItem::is_descendant_of(CanvasItem *ancestor)
+{
+ auto item = this;
+ while (item) {
+ if (item == ancestor) {
+ return true;
+ }
+ item = item->get_parent();
+ }
+ return false;
+}
+
+int CanvasItem::get_z_position()
+{
+ if (!_parent) {
+ std::cerr << "CanvasItem::get_z_position: No parent!" << std::endl;
+ return -1;
+ }
+
+ size_t position = 0;
+ for (auto it = _parent->items.begin(); it != _parent->items.end(); ++it, ++position) {
+ if (&*it == this) {
+ return position;
+ }
+ }
+
+ std::cerr << "CanvasItem::get_z_position: item not found!" << std::endl;
+ return -1;
+}
+
+void CanvasItem::set_z_position(unsigned int n)
+{
+ if (!_parent) {
+ std::cerr << "CanvasItem::set_z_position: No parent!" << std::endl;
+ }
+
+ if (n == 0) {
+ this->lower_to_bottom(); // Low cost operation
+ return;
+ }
+
+ if (n > _parent->items.size() - 2) {
+ this->raise_to_top(); // Low cost operation
+ return;
+ }
+
+ _parent->items.erase(_parent->items.iterator_to(*this));
+
+ size_t position = 0;
+ for (auto it = _parent->items.begin(); it != _parent->items.end(); ++it, ++position) {
+ if (position == n) {
+ _parent->items.insert(it, *this);
+ break;
+ }
+ }
+}
+
+void CanvasItem::raise_to_top()
+{
+ if (!_parent) {
+ std::cerr << "CanvasItem::raise_to_top: No parent!" << std::endl;
+ }
+
+ _parent->items.erase(_parent->items.iterator_to(*this));
+ _parent->items.push_back(*this);
+}
+
+void CanvasItem::lower_to_bottom()
+{
+ if (!_parent) {
+ std::cerr << "CanvasItem::lower_to_bottom: No parent!" << std::endl;
+ }
+
+ _parent->items.erase(_parent->items.iterator_to(*this));
+ _parent->items.push_front(*this);
+}
+
+// Indicate geometry changed and bounds needs recalculating.
+void CanvasItem::request_update()
+{
+ _need_update = true;
+ if (_parent) {
+ _parent->request_update();
+ } else {
+ _canvas->request_update();
+ }
+}
+
+void CanvasItem::show()
+{
+ if (_visible) {
+ return; // Already visible.
+ }
+
+ _visible = true;
+ // update bounds when visibility changes
+ request_update();
+ request_redraw();
+}
+
+int CanvasItem::grab(Gdk::EventMask event_mask, GdkCursor *cursor)
+{
+ return grab(event_mask, Glib::wrap(cursor));
+}
+
+// Grab all events! TODO: Return boolean
+int CanvasItem::grab(Gdk::EventMask event_mask, Glib::RefPtr<Gdk::Cursor> cursor)
+{
+#ifdef CANVAS_ITEM_DEBUG
+ std::cout << "CanvasItem::grab: " << _name << std::endl;
+#endif
+ // Don't grab if we already have a grabbed item!
+ if (_canvas->get_grabbed_canvas_item()) {
+ return -1;
+ }
+
+ auto const display = Gdk::Display::get_default();
+ auto const seat = display->get_default_seat();
+ auto const window = _canvas->get_window();
+ seat->grab(window, Gdk::SEAT_CAPABILITY_ALL_POINTING, false, cursor, nullptr);
+
+ _canvas->set_grabbed_canvas_item(this, event_mask);
+ _canvas->set_current_canvas_item(this); // So that all events go to grabbed item.
+ return 0;
+}
+
+void CanvasItem::ungrab()
+{
+#ifdef CANVAS_ITEM_DEBUG
+ std::cout << "CanvasItem::ungrab: " << _name << std::endl;
+#endif
+ if (_canvas->get_grabbed_canvas_item() != this) {
+ return; // Sanity check
+ }
+
+ _canvas->set_grabbed_canvas_item(nullptr, (Gdk::EventMask)0); // Zero mask
+
+ auto const display = Gdk::Display::get_default();
+ auto const seat = display->get_default_seat();
+ seat->ungrab();
+}
+
+void CanvasItem::hide()
+{
+ if (!_visible) {
+ return; // Already hidden
+ }
+
+ _visible = false;
+ // update bounds when visibility changes
+ request_update();
+ request_redraw();
+}
+
+void CanvasItem::set_fill(guint32 rgba)
+{
+ if (_fill != rgba) {
+ _fill = rgba;
+ request_redraw();
+ }
+}
+
+void CanvasItem::set_stroke(guint32 rgba)
+{
+ if (_stroke != rgba) {
+ _stroke = rgba;
+ request_redraw();
+ }
+}
+
+void CanvasItem::request_redraw() {
+ if (_canvas) {
+ // Queue redraw request
+ _canvas->redraw_area(_bounds);
+ }
+}
+
+} // Namespace Inkscape
+
+void canvas_item_print_tree(Inkscape::CanvasItem *item)
+{
+ static int level = 0;
+ if (level == 0) {
+ std::cout << "Canvas Item Tree" << std::endl;
+ }
+
+ std::cout << "CC: ";
+ for (unsigned i = 0; i < level; ++i) {
+ std::cout << " ";
+ }
+
+ std::cout << item->get_z_position() << ": " << item->get_name() << std::endl;
+
+ auto group = dynamic_cast<Inkscape::CanvasItemGroup *>(item);
+ if (group) {
+ ++level;
+ for (auto & item : group->items) {
+ canvas_item_print_tree(&item);
+ }
+ --level;
+ }
+}
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-item.h b/src/display/control/canvas-item.h
new file mode 100644
index 0000000..37d5ec7
--- /dev/null
+++ b/src/display/control/canvas-item.h
@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_CANVAS_ITEM_H
+#define SEEN_CANVAS_ITEM_H
+
+/**
+ * Abstract base class for on-canvas control items.
+ */
+
+/*
+ * Author:
+ * Tavmjong Bah
+ *
+ * Copyright (C) 2020 Tavmjong Bah
+ *
+ * Rewrite of SPCanvasItem
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ *
+ * A note about coordinates:
+ *
+ * 1. Canvas items are constructed using document (SVG) coordinates.
+ * 2. Calculations are made in canvas units, which is equivalent of SVG units multiplied by zoom factor.
+ * This is true for bounds and closest distance calculations.
+ * 3 Drawing is done in screen units which is the same as canvas units but translated.
+ * The document and canvas origins overlap.
+ * The affine contains only scaling and rotating components.
+ */
+
+//#define CANVAS_ITEM_DEBUG
+
+#include <gdk/gdk.h> // GdkEvent
+#include <gdkmm/device.h> // Gdk::EventMask
+#include <glib.h> // guint32
+#include <sigc++/sigc++.h>
+
+#include <2geom/rect.h>
+
+#include <boost/intrusive/list.hpp>
+
+#include "canvas-item-buffer.h"
+#include "canvas-item-enums.h"
+
+class SPItem;
+
+namespace Inkscape {
+
+static guint32 CANVAS_ITEM_COLORS[] = { 0x0000ff7f, 0xff00007f, 0xffff007f };
+
+namespace UI::Widget {
+class Canvas;
+}
+
+class CanvasItemGroup; // A canvas control that contains other canvas controls.
+
+class CanvasItem {
+
+public:
+ CanvasItem(CanvasItemGroup* group);
+ virtual ~CanvasItem();
+
+ // Structure
+ void set_canvas(UI::Widget::Canvas *canvas) { _canvas = canvas; }
+ UI::Widget::Canvas* get_canvas() { return _canvas; }
+
+ void set_parent(CanvasItemGroup *parent) { _parent = parent; }
+ CanvasItemGroup* get_parent() { return _parent; }
+
+ void set_item(SPItem *item) { _item = item; }
+ SPItem* get_item() { return _item; }
+
+ // Z Position
+ bool is_descendant_of(CanvasItem *ancestor);
+ void set_z_position(unsigned int n);
+ int get_z_position(); // z position in group.
+ // void raise_by(unsigned int n);
+ void raise_to_top(); // Move to top of group (last entry).
+ // void lower_by(unsigned int n);
+ void lower_to_bottom(); // Move to bottom of group (first entry).
+
+ // Geometry
+ void request_update();
+ virtual void update(Geom::Affine const &affine) = 0;
+ Geom::Affine get_affine() { return _affine; }
+ Geom::Rect get_bounds() { return _bounds; }
+
+ // Selection
+ virtual bool contains(Geom::Point const &p, double tolerance = 0) { return _bounds.interiorContains(p); }
+ int grab(Gdk::EventMask event_mask, GdkCursor *cursor = nullptr);
+ int grab(Gdk::EventMask event_mask, Glib::RefPtr<Gdk::Cursor> cursor);
+ void ungrab();
+
+ // Display
+ virtual void render(Inkscape::CanvasItemBuffer *buf) = 0;
+ bool is_visible() { return _visible; }
+ virtual void hide();
+ virtual void show();
+ void request_redraw(); // queue redraw request
+
+ // Properties
+ virtual void set_fill(guint32 rgba);
+ void set_fill(CanvasItemColor color) { set_fill(CANVAS_ITEM_COLORS[color]); }
+ virtual void set_stroke(guint32 rgba);
+ void set_stroke(CanvasItemColor color) { set_stroke(CANVAS_ITEM_COLORS[color]); }
+ void set_name(std::string const &name) { _name = name; }
+ std::string get_name() { return _name; }
+
+ // Events
+ void set_pickable(bool pickable) { _pickable = pickable; }
+ bool is_pickable() { return _pickable; }
+ sigc::connection connect_event(sigc::slot<bool, GdkEvent*> slot) {
+ return _event_signal.connect(slot);
+ }
+ virtual bool handle_event(GdkEvent *event) {
+ return _event_signal.emit(event); // Default just emit event.
+ }
+
+ // Boost linked list member hook, speeds deletion.
+ boost::intrusive::list_member_hook<> member_hook;
+
+protected:
+
+ // Structure
+ CanvasItemGroup *_parent = nullptr;
+ Inkscape::UI::Widget::Canvas *_canvas = nullptr;
+ SPItem *_item; // The object this canvas item is linked to in some sense. Can be nullptr.
+
+ // Geometry
+ Geom::Rect _bounds;
+ Geom::Affine _affine;
+ bool _need_update = true; // Need update after creation!
+
+ // Display
+ bool _visible = true;
+ bool _align_to_drawing = false; // Rotate if drawing is rotated. TODO: Implement!
+
+ // Selection
+ bool _pickable = false; // Most items are just for display and are not pickable!
+
+ // Properties
+ guint32 _fill = CANVAS_ITEM_COLORS[CANVAS_ITEM_SECONDARY];
+ guint32 _stroke = CANVAS_ITEM_COLORS[CANVAS_ITEM_PRIMARY];
+ std::string _name; // For debugging
+
+ // Events
+ sigc::signal<bool, GdkEvent*> _event_signal;
+};
+
+
+} // namespace Inkscape
+
+/** Type for linked list storing CanvasItem's.
+ *
+ * Used to speed deletion when a group contains a large number of item's (as in nodes for a
+ * complex path).
+ */
+typedef boost::intrusive::list<
+ Inkscape::CanvasItem,
+ boost::intrusive::member_hook<Inkscape::CanvasItem, boost::intrusive::list_member_hook<>,
+ &Inkscape::CanvasItem::member_hook> > CanvasItemList;
+
+// Recursively print CanvasItem tree.
+void canvas_item_print_tree(Inkscape::CanvasItem *item);
+
+#endif // SEEN_CANVAS_ITEM_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 :
diff --git a/src/display/control/canvas-page.cpp b/src/display/control/canvas-page.cpp
new file mode 100644
index 0000000..d6b363f
--- /dev/null
+++ b/src/display/control/canvas-page.cpp
@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape pages implementation
+ *
+ * Authors:
+ * Martin Owens <doctormo@geek-2.com>
+ *
+ * Copyright (C) 2021 Martin Owens
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-page.h"
+#include "canvas-item-rect.h"
+#include "canvas-item-text.h"
+
+namespace Inkscape {
+
+CanvasPage::~CanvasPage()
+{
+ for (auto item : canvas_items) {
+ delete item;
+ }
+ canvas_items.clear();
+}
+
+/**
+ * Add the page canvas to the given canvas item groups (canvas view is implicit)
+ */
+void CanvasPage::add(Geom::Rect size, CanvasItemGroup *background_group, CanvasItemGroup *border_group)
+{
+ // Foreground 'border'
+ if (auto item = new CanvasItemRect(border_group, size)) {
+ item->set_name("foreground");
+ canvas_items.push_back(item);
+ }
+
+ // Background rectangle 'fill'
+ if (auto item = new CanvasItemRect(background_group, size)) {
+ item->set_name("background");
+ item->set_dashed(false);
+ item->set_inverted(false);
+ item->set_stroke(0x00000000);
+ canvas_items.push_back(item);
+ }
+
+ if (auto label = new CanvasItemText(border_group, Geom::Point(0, 0), "{Page Label}")) {
+ label->set_fontsize(10.0);
+ label->set_fill(0xffffffff);
+ label->set_background(0x00000099);
+ label->set_bg_radius(0.2);
+ label->set_anchor(Geom::Point(0.0, 1.0));
+ label->set_fixed_line(true);
+ canvas_items.push_back(label);
+ }
+}
+/**
+ * Hide the page in the given canvas widget.
+ */
+void CanvasPage::remove(UI::Widget::Canvas *canvas)
+{
+ g_assert(canvas != nullptr);
+ for (auto it = canvas_items.begin(); it != canvas_items.end();) {
+ if (canvas == (*it)->get_canvas()) {
+ delete (*it);
+ it = canvas_items.erase(it);
+ } else {
+ ++it;
+ }
+ }
+}
+
+void CanvasPage::show()
+{
+ for (auto item : canvas_items) {
+ item->show();
+ }
+}
+
+void CanvasPage::hide()
+{
+ for (auto item : canvas_items) {
+ item->hide();
+ }
+}
+
+/**
+ * Update the visual representation of a page on screen.
+ *
+ * @param size - The size of the page in desktop units
+ * @param txt - An optional label for the page
+ * @param outline - Disable normal rendering and show as an outline.
+ */
+void CanvasPage::update(Geom::Rect size, const char *txt, bool outline)
+{
+ // Put these in the preferences?
+ bool border_on_top = _border_on_top;
+ guint32 shadow_color = _border_color; // there's no separate shadow color in the UI, border color is used
+ guint32 select_color = 0xff0000cc;
+ guint32 border_color = _border_color;
+
+ // This is used when showing the viewport as *not a page* it's mostly
+ // never used as the first page is normally the viewport too.
+ if (outline) {
+ border_on_top = false;
+ _shadow_size = 0;
+ border_color = select_color;
+ }
+
+ for (auto item : canvas_items) {
+ if (auto rect = dynamic_cast<CanvasItemRect *>(item)) {
+ rect->set_rect(size);
+
+ bool is_foreground = (rect->get_name() == "foreground");
+ // This will put the border on the background OR foreground layer as needed.
+ if (is_foreground == border_on_top) {
+ rect->show();
+ rect->set_shadow(shadow_color, _shadow_size);
+ rect->set_stroke(is_selected ? select_color : border_color);
+ } else {
+ rect->hide();
+ rect->set_shadow(0x0, 0);
+ rect->set_stroke(0x0);
+ }
+ // This undoes the hide for the background rect, but that's ok
+ if (!is_foreground) {
+ rect->show();
+ if (_checkerboard) {
+ rect->set_background_checkerboard(_background_color, true);
+ }
+ else {
+ // TODO: This ignores the requested transparency to paint the background.
+ // there is disagreement between developers about this feature.
+ rect->set_background(_background_color | 0xff);
+ }
+ }
+ }
+ if (auto label = dynamic_cast<CanvasItemText *>(item)) {
+ if (txt) {
+ auto corner = size.corner(0);
+ label->set_coord(corner);
+ label->set_text(txt);
+ label->show();
+ } else {
+ label->set_text("");
+ label->hide();
+ }
+ }
+ }
+}
+
+bool CanvasPage::setAttributes(bool on_top, guint32 border, guint32 bg, int shadow, bool checkerboard)
+{
+ if (on_top != _border_on_top || border != _border_color || bg != _background_color || shadow != _shadow_size || checkerboard != _checkerboard) {
+ this->_border_on_top = on_top;
+ this->_border_color = border;
+ this->_background_color = bg;
+ _shadow_size = shadow;
+ _checkerboard = checkerboard;
+ return true;
+ }
+ return false;
+}
+
+};
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-page.h b/src/display/control/canvas-page.h
new file mode 100644
index 0000000..db66b4f
--- /dev/null
+++ b/src/display/control/canvas-page.h
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ *
+ *//*
+ * Authors:
+ * Martin Owens 2021
+ *
+ * Copyright (C) 2021 Martin Owens
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+#ifndef SEEN_CANVAS_PAGE_H
+#define SEEN_CANVAS_PAGE_H
+
+#include <2geom/rect.h>
+#include <glib.h>
+#include <vector>
+
+#include "canvas-item.h"
+
+namespace Inkscape {
+ namespace UI {
+ namespace Widget {
+ class Canvas;
+ };
+ };
+
+ class CanvasItemGroup;
+
+class CanvasPage
+{
+public:
+ CanvasPage() = default;
+ ~CanvasPage();
+
+ void update(Geom::Rect size, const char *txt, bool outline = false);
+ void add(Geom::Rect size, CanvasItemGroup *background_group, CanvasItemGroup *foreground_group);
+ void remove(UI::Widget::Canvas *canvas);
+ void show();
+ void hide();
+
+ bool setAttributes(bool on_top, guint32 border, guint32 bg, int shadow, bool checkerboard);
+ void setOutline(bool outline);
+
+ bool is_selected = false;
+private:
+ // This may make this look like a CanvasItemGroup, but it's not one. This
+ // isn't a collection of items, but a set of items in multiple Canvases.
+ // Each item can belong in either a foreground or background group.
+ std::vector<Inkscape::CanvasItem *> canvas_items;
+
+ int _shadow_size = 0;
+ bool _border_on_top = true;
+ guint32 _background_color = 0xffffff00;
+ guint32 _border_color = 0x00000040;
+ bool _checkerboard = false;
+};
+
+};
+
+#endif // SEEN_CANVAS_PAGE_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 :
diff --git a/src/display/control/canvas-temporary-item-list.cpp b/src/display/control/canvas-temporary-item-list.cpp
new file mode 100644
index 0000000..4be97f9
--- /dev/null
+++ b/src/display/control/canvas-temporary-item-list.cpp
@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Provides a class that can contain active TemporaryItem's on a desktop
+ * Code inspired by message-stack.cpp
+ *
+ * Authors:
+ * Johan Engelen
+ *
+ * Copyright (C) Johan Engelen 2008 <j.b.c.engelen@utwente.nl>
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "canvas-temporary-item.h"
+#include "canvas-temporary-item-list.h"
+
+namespace Inkscape {
+namespace Display {
+
+TemporaryItemList::TemporaryItemList(SPDesktop *desktop)
+ : desktop(desktop)
+{
+
+}
+
+TemporaryItemList::~TemporaryItemList()
+{
+ // delete all items in list so the timeouts are removed
+ for (auto tempitem : itemlist) {
+ delete tempitem;
+ }
+ itemlist.clear();
+}
+
+/* Note that TemporaryItem or TemporaryItemList is responsible for deletion and such, so this return pointer can safely be ignored. */
+TemporaryItem *
+TemporaryItemList::add_item(CanvasItem *item, unsigned int lifetime)
+{
+ // beware of strange things happening due to very short timeouts
+ TemporaryItem * tempitem;
+ if (lifetime == 0)
+ tempitem = new TemporaryItem(item, 0, true);
+ else {
+ tempitem = new TemporaryItem(item, lifetime);
+ tempitem->signal_timeout.connect( sigc::mem_fun(*this, &TemporaryItemList::_item_timeout) );
+ }
+
+ itemlist.push_back(tempitem);
+ return tempitem;
+}
+
+void
+TemporaryItemList::delete_item( TemporaryItem * tempitem )
+{
+ // check if the item is in the list, if so, delete it. (in other words, don't wait for the item to delete itself)
+ bool in_list = false;
+ for (auto & it : itemlist) {
+ if ( it == tempitem ) {
+ in_list = true;
+ break;
+ }
+ }
+ if (in_list) {
+ itemlist.remove(tempitem);
+ delete tempitem;
+ }
+}
+
+void
+TemporaryItemList::_item_timeout(TemporaryItem * tempitem)
+{
+ itemlist.remove(tempitem);
+ // no need to delete the item, it does that itself after signal_timeout.emit() completes
+}
+
+} //namespace Display
+} /* namespace Inkscape */
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-temporary-item-list.h b/src/display/control/canvas-temporary-item-list.h
new file mode 100644
index 0000000..29b270a
--- /dev/null
+++ b/src/display/control/canvas-temporary-item-list.h
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef INKSCAPE_CANVAS_TEMPORARY_ITEM_LIST_H
+#define INKSCAPE_CANVAS_TEMPORARY_ITEM_LIST_H
+
+/*
+ * Authors:
+ * Johan Engelen
+ *
+ * Copyright (C) Johan Engelen 2008 <j.b.c.engelen@utwente.nl>
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <list>
+
+struct SPCanvasItem;
+class SPDesktop;
+
+namespace Inkscape {
+
+class CanvasItem;
+
+namespace Display {
+
+class TemporaryItem;
+
+/**
+ * Provides a class that can contain active TemporaryItem[s] on a desktop.
+ */
+class TemporaryItemList {
+public:
+ TemporaryItemList(SPDesktop *desktop);
+ virtual ~TemporaryItemList();
+
+ TemporaryItem* add_item (SPCanvasItem *item, unsigned int lifetime);
+ TemporaryItem* add_item (CanvasItem *item, unsigned int lifetime);
+ void delete_item (TemporaryItem * tempitem);
+
+protected:
+ SPDesktop *desktop; /** Desktop we are on. */
+
+ std::list<TemporaryItem *> itemlist; /** list of temp items */
+
+ void _item_timeout (TemporaryItem * tempitem);
+
+private:
+ TemporaryItemList(const TemporaryItemList&) = delete;
+ TemporaryItemList& operator=(const TemporaryItemList&) = delete;
+};
+
+} //namespace Display
+} //namespace Inkscape
+
+#endif
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-temporary-item.cpp b/src/display/control/canvas-temporary-item.cpp
new file mode 100644
index 0000000..08a8607
--- /dev/null
+++ b/src/display/control/canvas-temporary-item.cpp
@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Provides a class that can contain active TemporaryItem's on a desktop
+ * When the object is deleted, it also deletes the canvasitem it contains!
+ * This object should be created/managed by a TemporaryItemList.
+ * After its lifetime, it fires the timeout signal, afterwards *it deletes itself*.
+ *
+ * (part of code inspired by message-stack.cpp)
+ *
+ * Authors:
+ * Johan Engelen
+ *
+ * Copyright (C) Johan Engelen 2008 <j.b.c.engelen@utwente.nl>
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glib.h>
+
+#include "canvas-temporary-item.h"
+
+#include "canvas-item.h"
+
+namespace Inkscape {
+namespace Display {
+
+/** lifetime is measured in milliseconds
+ */
+TemporaryItem::TemporaryItem(CanvasItem *item, guint lifetime, bool deselect_destroy)
+ : canvasitem(item),
+ timeout_id(0),
+ destroy_on_deselect(deselect_destroy)
+{
+ if (lifetime > 0 && destroy_on_deselect) {
+ g_print ("Warning: lifetime should be 0 when destroy_on_deselect is true\n");
+ lifetime = 0;
+ }
+ // zero lifetime means stay forever, so do not add timeout event.
+ if (lifetime > 0) {
+ timeout_id = g_timeout_add(lifetime, &TemporaryItem::_timeout, this);
+ }
+}
+
+TemporaryItem::~TemporaryItem()
+{
+ // when it has not expired yet...
+ if (timeout_id) {
+ g_source_remove(timeout_id);
+ timeout_id = 0;
+ }
+
+ if (canvasitem) {
+ // destroying the item automatically hides it
+ delete canvasitem;
+ canvasitem = nullptr;
+ }
+}
+
+/* static method */
+int TemporaryItem::_timeout(void* data) {
+ TemporaryItem *tempitem = static_cast<TemporaryItem *>(data);
+ tempitem->timeout_id = 0;
+ tempitem->signal_timeout.emit(tempitem);
+ delete tempitem;
+ return FALSE;
+}
+
+
+} //namespace Display
+} /* namespace Inkscape */
+
+/*
+ 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 :
diff --git a/src/display/control/canvas-temporary-item.h b/src/display/control/canvas-temporary-item.h
new file mode 100644
index 0000000..b2457c7
--- /dev/null
+++ b/src/display/control/canvas-temporary-item.h
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef INKSCAPE_CANVAS_TEMPORARY_ITEM_H
+#define INKSCAPE_CANVAS_TEMPORARY_ITEM_H
+
+/*
+ * Authors:
+ * Johan Engelen
+ *
+ * Copyright (C) Johan Engelen 2008 <j.b.c.engelen@utwente.nl>
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+
+#include <sigc++/signal.h>
+
+namespace Inkscape {
+
+class CanvasItem;
+
+namespace Display {
+
+/**
+ * Provides a class to put a canvasitem temporarily on-canvas.
+ */
+class TemporaryItem {
+public:
+ TemporaryItem(Inkscape::CanvasItem *item, unsigned int lifetime, bool destroy_on_deselect = false);
+ virtual ~TemporaryItem();
+
+ TemporaryItem(const TemporaryItem&) = delete;
+ TemporaryItem& operator=(const TemporaryItem&) = delete;
+
+ sigc::signal<void, TemporaryItem *> signal_timeout;
+
+protected:
+ friend class TemporaryItemList;
+
+ Inkscape::CanvasItem * canvasitem = nullptr; /** The item we are holding on to */
+ unsigned int timeout_id; /** ID by which glib knows the timeout event */
+ bool destroy_on_deselect; // only destroy when parent item is deselected, not when mouse leaves
+
+ static int _timeout(void* data); ///< callback for when lifetime expired
+};
+
+} //namespace Display
+} //namespace Inkscape
+
+#endif
+
+/*
+ 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 :
diff --git a/src/display/control/snap-indicator.cpp b/src/display/control/snap-indicator.cpp
new file mode 100644
index 0000000..4f42820
--- /dev/null
+++ b/src/display/control/snap-indicator.cpp
@@ -0,0 +1,640 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Provides a class that shows a temporary indicator on the canvas of where the snap was, and what kind of snap
+ *
+ * Authors:
+ * Johan Engelen
+ * Diederik van Lierop
+ *
+ * Copyright (C) Johan Engelen 2009 <j.b.c.engelen@utwente.nl>
+ * Copyright (C) Diederik van Lierop 2010 - 2012 <mail@diedenrezi.nl>
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/i18n.h>
+#include <string>
+#include <iomanip>
+#include <unordered_map>
+
+#include "snap-indicator.h"
+
+#include "desktop.h"
+#include "enums.h"
+#include "preferences.h"
+#include "util/units.h"
+#include "document.h"
+
+
+#include "canvas-item-ctrl.h"
+#include "canvas-item-rect.h"
+#include "canvas-item-text.h"
+#include "canvas-item-curve.h"
+
+#include "ui/tools/measure-tool.h"
+
+#define DISTANCE_BG_RADIUS 0.3
+
+namespace Inkscape {
+namespace Display {
+
+static std::map<SnapSourceType, Glib::ustring> source2string = {
+ {SNAPSOURCE_UNDEFINED, _("UNDEFINED")},
+ {SNAPSOURCE_BBOX_CORNER, _("Bounding box corner")},
+ {SNAPSOURCE_BBOX_MIDPOINT, _("Bounding box midpoint")},
+ {SNAPSOURCE_BBOX_EDGE_MIDPOINT, _("Bounding box side midpoint")},
+ {SNAPSOURCE_NODE_SMOOTH, _("Smooth node")},
+ {SNAPSOURCE_NODE_CUSP, _("Cusp node")},
+ {SNAPSOURCE_LINE_MIDPOINT, _("Line midpoint")},
+ {SNAPSOURCE_PATH_INTERSECTION, _("Path intersection")},
+ {SNAPSOURCE_RECT_CORNER, _("Corner")},
+ {SNAPSOURCE_CONVEX_HULL_CORNER, _("Convex hull corner")},
+ {SNAPSOURCE_ELLIPSE_QUADRANT_POINT, _("Quadrant point")},
+ {SNAPSOURCE_NODE_HANDLE, _("Handle")},
+ {SNAPSOURCE_GUIDE, _("Guide")},
+ {SNAPSOURCE_GUIDE_ORIGIN, _("Guide origin")},
+ {SNAPSOURCE_ROTATION_CENTER, _("Object rotation center")},
+ {SNAPSOURCE_OBJECT_MIDPOINT, _("Object midpoint")},
+ {SNAPSOURCE_IMG_CORNER, _("Corner")},
+ {SNAPSOURCE_TEXT_ANCHOR, _("Text anchor")},
+ {SNAPSOURCE_OTHER_HANDLE, _("Handle")},
+ {SNAPSOURCE_GRID_PITCH, _("Multiple of grid spacing")},
+ {SNAPSOURCE_PAGE_CORNER, _("Page corner")},
+ {SNAPSOURCE_PAGE_CENTER, _("Page center")},
+};
+
+static std::map<SnapTargetType, Glib::ustring> target2string = {
+ {SNAPTARGET_UNDEFINED, _("UNDEFINED")},
+ {SNAPTARGET_BBOX_CORNER, _("bounding box corner")},
+ {SNAPTARGET_BBOX_EDGE, _("bounding box side")},
+ {SNAPTARGET_BBOX_EDGE_MIDPOINT, _("bounding box side midpoint")},
+ {SNAPTARGET_BBOX_MIDPOINT, _("bounding box midpoint")},
+ {SNAPTARGET_NODE_SMOOTH, _("smooth node")},
+ {SNAPTARGET_NODE_CUSP, _("cusp node")},
+ {SNAPTARGET_LINE_MIDPOINT, _("line midpoint")},
+ {SNAPTARGET_PATH, _("path")},
+ {SNAPTARGET_PATH_PERPENDICULAR, _("path (perpendicular)")},
+ {SNAPTARGET_PATH_TANGENTIAL, _("path (tangential)")},
+ {SNAPTARGET_PATH_INTERSECTION, _("path intersection")},
+ {SNAPTARGET_PATH_GUIDE_INTERSECTION, _("guide-path intersection")},
+ {SNAPTARGET_PATH_CLIP, _("clip-path")},
+ {SNAPTARGET_PATH_MASK, _("mask-path")},
+ {SNAPTARGET_ELLIPSE_QUADRANT_POINT, _("quadrant point")},
+ {SNAPTARGET_RECT_CORNER, _("corner")},
+ {SNAPTARGET_GRID, _("grid line")},
+ {SNAPTARGET_GRID_INTERSECTION, _("grid intersection")},
+ {SNAPTARGET_GRID_PERPENDICULAR, _("grid line (perpendicular)")},
+ {SNAPTARGET_GUIDE, _("guide")},
+ {SNAPTARGET_GUIDE_INTERSECTION, _("guide intersection")},
+ {SNAPTARGET_GUIDE_ORIGIN, _("guide origin")},
+ {SNAPTARGET_GUIDE_PERPENDICULAR, _("guide (perpendicular)")},
+ {SNAPTARGET_GRID_GUIDE_INTERSECTION, _("grid-guide intersection")},
+ {SNAPTARGET_PAGE_BORDER, _("page border")},
+ {SNAPTARGET_PAGE_CORNER, _("page corner")},
+ {SNAPTARGET_PAGE_CENTER, _("page center")},
+ {SNAPTARGET_OBJECT_MIDPOINT, _("object midpoint")},
+ {SNAPTARGET_IMG_CORNER, _("corner")},
+ {SNAPTARGET_ROTATION_CENTER, _("object rotation center")},
+ {SNAPTARGET_TEXT_ANCHOR, _("text anchor")},
+ {SNAPTARGET_TEXT_BASELINE, _("text baseline")},
+ {SNAPTARGET_CONSTRAINED_ANGLE, _("constrained angle")},
+ {SNAPTARGET_CONSTRAINT, _("constraint")},
+};
+
+SnapIndicator::SnapIndicator(SPDesktop * desktop)
+ : _snaptarget(nullptr),
+ _snaptarget_tooltip(nullptr),
+ _snaptarget_bbox(nullptr),
+ _snapsource(nullptr),
+ _snaptarget_is_presnap(false),
+ _desktop(desktop)
+{
+}
+
+SnapIndicator::~SnapIndicator()
+{
+ // remove item that might be present
+ remove_snaptarget();
+ remove_snapsource();
+}
+
+void
+SnapIndicator::set_new_snaptarget(Inkscape::SnappedPoint const &p, bool pre_snap)
+{
+ remove_snaptarget(); //only display one snaptarget at a time
+
+ g_assert(_desktop != nullptr);
+
+ if (!p.getSnapped()) {
+ return; // If we haven't snapped, then it is of no use to draw a snapindicator
+ }
+
+ if (p.getTarget() == SNAPTARGET_CONSTRAINT) {
+ // This is not a real snap, although moving along the constraint did affect the mouse pointer's position.
+ // Maybe we should only show a snap indicator when the user explicitly asked for a constraint by pressing ctrl?
+ // We should not show a snap indicator when stretching a selection box, which is also constrained. That would be
+ // too much information.
+ return;
+ }
+
+ bool is_alignment = p.getAlignmentTarget().has_value();
+ bool is_distribution = p.getTarget() & SNAPTARGET_DISTRIBUTION_CATEGORY;
+
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ double scale = prefs->getDouble("/tools/measure/scale", 100.0) / 100.0;
+
+ bool value = prefs->getBool("/options/snapindicator/value", true);
+
+ if (value) {
+ Glib::ustring target_name = _("UNDEFINED");
+ Glib::ustring source_name = _("UNDEFINED");
+
+ if (!is_alignment && !is_distribution) {
+ if (target2string.find(p.getTarget()) == target2string.end())
+ g_warning("Target type %i not present in target2string", p.getTarget());
+
+ if (source2string.find(p.getSource()) == source2string.end())
+ g_warning("Source type %i not present in target2string", p.getSource());
+
+ target_name = _(target2string[p.getTarget()].c_str());
+ source_name = _(source2string[p.getSource()].c_str());
+ }
+ //std::cout << "Snapped " << source_name << " to " << target_name << std::endl;
+
+ remove_snapsource(); // Don't set both the source and target indicators, as these will overlap
+
+ double timeout_val = prefs->getDouble("/options/snapindicatorpersistence/value", 2.0);
+ if (timeout_val < 0.1) {
+ timeout_val = 0.1; // a zero value would mean infinite persistence (i.e. until new snap occurs)
+ // Besides, negatives values would ....?
+ }
+
+ // TODO: should this be a constant or a separate prefrence
+ // we are using the preference of measure tool here.
+ double fontsize = prefs->getDouble("/tools/measure/fontsize", 10.0);
+
+ if (is_distribution) {
+ make_distribution_indicators(p, fontsize, scale);
+ }
+
+ if (is_alignment) {
+ auto color = pre_snap ? 0x7f7f7fff : get_guide_color(p.getAlignmentTargetType());
+ make_alignment_indicator(p.getPoint(), *p.getAlignmentTarget(), color, fontsize, scale);
+ if (p.getAlignmentTargetType() == SNAPTARGET_ALIGNMENT_INTERSECTION) {
+ make_alignment_indicator(p.getPoint(), *p.getAlignmentTarget2(), color, fontsize, scale);
+ }
+ }
+
+ _snaptarget_is_presnap = pre_snap;
+
+ // Display the snap indicator (i.e. the cross)
+ Inkscape::CanvasItemCtrl *ctrl;
+
+ if (!is_alignment && !is_distribution) {
+ // Display snap indicator at snap target
+ ctrl = new Inkscape::CanvasItemCtrl(_desktop->getCanvasTemp(), Inkscape::CANVAS_ITEM_CTRL_SHAPE_CROSS);
+ ctrl->set_size(11);
+ ctrl->set_stroke( pre_snap ? 0x7f7f7fff : 0xff0000ff);
+ ctrl->set_position(p.getPoint());
+
+ _snaptarget = _desktop->add_temporary_canvasitem(ctrl, timeout_val*1000.0);
+ // The snap indicator will be deleted after some time-out, and sp_canvas_item_dispose
+ // will be called. This will set canvas->current_item to NULL if the snap indicator was
+ // the current item, after which any events will go to the root handler instead of any
+ // item handler. Dragging an object which has just snapped might therefore not be possible
+ // without selecting / repicking it again. To avoid this, we make sure here that the
+ // snap indicator will never be picked, and will therefore never be the current item.
+ // Reported bugs:
+ // - scrolling when hovering above a pre-snap indicator won't work (for example)
+ // (https://bugs.launchpad.net/inkscape/+bug/522335/comments/8)
+ // - dragging doesn't work without repicking
+ // (https://bugs.launchpad.net/inkscape/+bug/1420301/comments/15)
+ ctrl->set_pickable(false);
+
+ // Display the tooltip, which reveals the type of snap source and the type of snap target
+ Glib::ustring tooltip_str;
+ if ( (p.getSource() != SNAPSOURCE_GRID_PITCH) && (p.getTarget() != SNAPTARGET_UNDEFINED) ) {
+ tooltip_str = source_name + _(" to ") + target_name;
+ } else if (p.getSource() != SNAPSOURCE_UNDEFINED) {
+ tooltip_str = source_name;
+ }
+
+
+ if (!tooltip_str.empty()) {
+ Geom::Point tooltip_pos = p.getPoint();
+ if (dynamic_cast<Inkscape::UI::Tools::MeasureTool *>(_desktop->event_context)) {
+ // Make sure that the snap tooltips do not overlap the ones from the measure tool
+ tooltip_pos += _desktop->w2d(Geom::Point(0, -3*fontsize));
+ } else {
+ tooltip_pos += _desktop->w2d(Geom::Point(0, -2*fontsize));
+ }
+
+ auto canvas_tooltip = new Inkscape::CanvasItemText(_desktop->getCanvasTemp(), tooltip_pos, tooltip_str);
+ canvas_tooltip->set_fontsize(fontsize);
+ canvas_tooltip->set_fill(0xffffffff);
+ canvas_tooltip->set_background(pre_snap ? 0x33337f40 : 0x33337f7f);
+
+ _snaptarget_tooltip = _desktop->add_temporary_canvasitem(canvas_tooltip, timeout_val*1000.0);
+ }
+
+ // Display the bounding box, if we snapped to one
+ Geom::OptRect const bbox = p.getTargetBBox();
+ if (bbox) {
+ auto box = new Inkscape::CanvasItemRect(_desktop->getCanvasTemp(), *bbox);
+ box->set_stroke(pre_snap ? 0x7f7f7fff : 0xff0000ff);
+ box->set_dashed(true);
+ box->set_pickable(false); // Is false by default.
+ box->set_z_position(0);
+ _snaptarget_bbox = _desktop->add_temporary_canvasitem(box, timeout_val*1000.0);
+ }
+ }
+ }
+}
+
+void
+SnapIndicator::remove_snaptarget(bool only_if_presnap)
+{
+ if (only_if_presnap && !_snaptarget_is_presnap) {
+ return;
+ }
+
+ if (_snaptarget) {
+ _desktop->remove_temporary_canvasitem(_snaptarget);
+ _snaptarget = nullptr;
+ _snaptarget_is_presnap = false;
+ }
+
+ if (_snaptarget_tooltip) {
+ _desktop->remove_temporary_canvasitem(_snaptarget_tooltip);
+ _snaptarget_tooltip = nullptr;
+ }
+
+ if (_snaptarget_bbox) {
+ _desktop->remove_temporary_canvasitem(_snaptarget_bbox);
+ _snaptarget_bbox = nullptr;
+ }
+
+ for (auto *item : _alignment_snap_indicators) {
+ _desktop->remove_temporary_canvasitem(item);
+ }
+ _alignment_snap_indicators.clear();
+
+ for (auto *item : _distribution_snap_indicators) {
+ _desktop->remove_temporary_canvasitem(item);
+ }
+ _distribution_snap_indicators.clear();
+}
+
+void
+SnapIndicator::set_new_snapsource(Inkscape::SnapCandidatePoint const &p)
+{
+ remove_snapsource();
+
+ g_assert(_desktop != nullptr); // If this fails, then likely setup() has not been called on the snap manager (see snap.cpp -> setup())
+
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ bool value = prefs->getBool("/options/snapindicator/value", true);
+
+ if (value) {
+ auto ctrl = new Inkscape::CanvasItemCtrl(_desktop->getCanvasTemp(), Inkscape::CANVAS_ITEM_CTRL_SHAPE_CIRCLE);
+ ctrl->set_size(7);
+ ctrl->set_stroke(0xff0000ff);
+ ctrl->set_position(p.getPoint());
+ _snapsource = _desktop->add_temporary_canvasitem(ctrl, 1000);
+ }
+}
+
+void
+SnapIndicator::set_new_debugging_point(Geom::Point const &p)
+{
+ g_assert(_desktop != nullptr);
+ auto ctrl = new Inkscape::CanvasItemCtrl(_desktop->getCanvasTemp(), Inkscape::CANVAS_ITEM_CTRL_SHAPE_DIAMOND);
+ ctrl->set_size(11);
+ ctrl->set_stroke(0x00ff00ff);
+ ctrl->set_position(p);
+ _debugging_points.push_back(_desktop->add_temporary_canvasitem(ctrl, 5000));
+}
+
+void
+SnapIndicator::remove_snapsource()
+{
+ if (_snapsource) {
+ _desktop->remove_temporary_canvasitem(_snapsource);
+ _snapsource = nullptr;
+ }
+}
+
+void
+SnapIndicator::remove_debugging_points()
+{
+ for (std::list<TemporaryItem *>::const_iterator i = _debugging_points.begin(); i != _debugging_points.end(); ++i) {
+ _desktop->remove_temporary_canvasitem(*i);
+ }
+ _debugging_points.clear();
+}
+
+guint32 SnapIndicator::get_guide_color(SnapTargetType t)
+{
+ switch(t) {
+ case SNAPTARGET_ALIGNMENT_BBOX_CORNER:
+ case SNAPTARGET_ALIGNMENT_BBOX_MIDPOINT:
+ case SNAPTARGET_ALIGNMENT_BBOX_EDGE_MIDPOINT:
+ return 0xff0000ff;
+ case SNAPTARGET_ALIGNMENT_PAGE_CENTER:
+ case SNAPTARGET_ALIGNMENT_PAGE_CORNER:
+ return 0x00ff00ff;
+ case SNAPTARGET_ALIGNMENT_HANDLE:
+ return 0x0000ffff;
+ case SNAPTARGET_ALIGNMENT_INTERSECTION:
+ return 0xd13bd1ff;
+ default:
+ g_warning("Alignment guide color not handled %i", t);
+ return 0x000000ff;
+ }
+}
+
+std::pair<Geom::Coord, int> get_y_and_sign(Geom::Rect const &source, Geom::Rect const &target, double const offset)
+{
+ Geom::Coord y;
+ int sign;
+
+ // We add a margin of 5px here to make sure that very small movements of mouse
+ // pointer do not cause the position of distribution indicator to change.
+ if (source.midpoint().y() < target.midpoint().y() + 5) {
+ y = source.max().y() + offset;
+ sign = 1;
+ } else {
+ y = source.min().y() - offset;
+ sign = -1;
+ }
+
+ return {y, sign};
+}
+
+std::pair<Geom::Coord, int> get_x_and_sign(Geom::Rect const &source, Geom::Rect const &target, double const offset)
+{
+ Geom::Coord x;
+ int sign;
+
+ // We add a margin of 5px here to make sure that very small movements of mouse
+ // pointer do not cause the position of distribution indicator to change.
+ if (source.midpoint().x() < target.midpoint().x() + 5) {
+ x = source.max().x() + offset;
+ sign = 1;
+ } else {
+ x = source.min().x() - offset;
+ sign = -1;
+ }
+
+ return {x, sign};
+}
+
+void SnapIndicator::make_alignment_indicator(Geom::Point const &p1, Geom::Point const &p2, guint32 color, double fontsize, double scale)
+{
+ //make sure the line is straight
+ g_assert(p1.x() == p2.x() || p1.y() == p2.y());
+
+ Preferences *prefs = Preferences::get();
+ bool show_distance = prefs->getBool("/options/snapindicatordistance/value", false);
+
+ Inkscape::CanvasItemCurve *line;
+
+ auto ctrl = new Inkscape::CanvasItemCtrl(_desktop->getCanvasTemp(), Inkscape::CANVAS_ITEM_CTRL_SHAPE_CIRCLE);
+ ctrl->set_size(7);
+ ctrl->set_mode(Inkscape::CanvasItemCtrlMode::CANVAS_ITEM_CTRL_MODE_COLOR);
+ ctrl->set_stroke(0xffffffff);
+ ctrl->set_fill(color);
+ ctrl->set_position(p1);
+ ctrl->set_pickable(false);
+ _alignment_snap_indicators.push_back(_desktop->add_temporary_canvasitem(ctrl, 0));
+
+ ctrl = new Inkscape::CanvasItemCtrl(_desktop->getCanvasTemp(), Inkscape::CANVAS_ITEM_CTRL_SHAPE_CIRCLE);
+ ctrl->set_size(7);
+ ctrl->set_mode(Inkscape::CanvasItemCtrlMode::CANVAS_ITEM_CTRL_MODE_COLOR);
+ ctrl->set_stroke(0xffffffff);
+ ctrl->set_fill(color);
+ ctrl->set_position(p2);
+ ctrl->set_pickable(false);
+ _alignment_snap_indicators.push_back(_desktop->add_temporary_canvasitem(ctrl, 0));
+
+ if (show_distance) {
+ auto dist = Geom::L2(p2 - p1);
+ double offset = (fontsize + 5)/_desktop->current_zoom();
+ auto direction = Geom::unit_vector(p1 - p2);
+ auto text_pos = (p1 + p2)/2;
+
+ Glib::ustring unit_name = _desktop->doc()->getDisplayUnit()->abbr.c_str();
+ if (!unit_name.compare("")) {
+ unit_name = DEFAULT_UNIT_NAME;
+ }
+
+ dist = Inkscape::Util::Quantity::convert(dist, "px", unit_name);
+
+ Glib::ustring distance = Glib::ustring::format(std::fixed, std::setprecision(1), std::noshowpoint, scale*dist);
+
+ auto text = new Inkscape::CanvasItemText(_desktop->getCanvasTemp(), text_pos, distance);
+ text->set_fontsize(fontsize);
+ text->set_fill(color);
+ text->set_background(0xffffffc8);
+ text->set_bg_radius(DISTANCE_BG_RADIUS);
+ text->set_anchor({0.5, 0.5});
+ _alignment_snap_indicators.push_back(_desktop->add_temporary_canvasitem(text, 0));
+
+ auto temp_point = text_pos + offset*direction;
+ line = new Inkscape::CanvasItemCurve(_desktop->getCanvasTemp(), p1, temp_point);
+ line->set_stroke(color);
+ line->set_bg_alpha(1.0f);
+ _alignment_snap_indicators.push_back(_desktop->add_temporary_canvasitem(line, 0));
+
+ temp_point = text_pos - offset*direction;
+ line = new Inkscape::CanvasItemCurve(_desktop->getCanvasTemp(), temp_point, p2);
+ line->set_stroke(color);
+ line->set_bg_alpha(1.0f);
+ _alignment_snap_indicators.push_back(_desktop->add_temporary_canvasitem(line, 0));
+ } else {
+ line = new Inkscape::CanvasItemCurve(_desktop->getCanvasTemp(), p1, p2);
+ line->set_stroke(color);
+ line->set_bg_alpha(1.0f);
+ _alignment_snap_indicators.push_back(_desktop->add_temporary_canvasitem(line, 0));
+ }
+}
+
+Inkscape::CanvasItemCurve* SnapIndicator::make_stub_line_v(Geom::Point const & p)
+{
+ Geom::Coord length = 10/_desktop->current_zoom();
+ auto line = new Inkscape::CanvasItemCurve(_desktop->getCanvasTemp(), p + Geom::Point(0, length/2), p - Geom::Point(0, length/2));
+ line->set_stroke(0xff5f1fff);
+ return line;
+}
+
+Inkscape::CanvasItemCurve* SnapIndicator::make_stub_line_h(Geom::Point const & p)
+{
+ Geom::Coord length = 10/_desktop->current_zoom();
+ auto line = new Inkscape::CanvasItemCurve(_desktop->getCanvasTemp(), p + Geom::Point(length/2, 0), p - Geom::Point(length/2, 0));
+ line->set_stroke(0xff5f1fff);
+ return line;
+}
+
+void SnapIndicator::make_distribution_indicators(SnappedPoint const &p,
+ double fontsize,
+ double scale)
+{
+ Preferences *prefs = Preferences::get();
+ bool show_distance = prefs->getBool("/options/snapindicatordistance/value", false);
+
+ guint32 color = 0xff5f1fff;
+ guint32 text_fill = 0xffffffff;
+ guint32 text_bg = 0xff5f1fff; //0x33337f7f
+ Geom::Point text_pos;
+ double text_offset = (fontsize * 2);
+ // double line_offset = 5/_desktop->current_zoom();
+ double line_offset = 0;
+
+ Glib::ustring unit_name = _desktop->doc()->getDisplayUnit()->abbr.c_str();
+ if (!unit_name.compare("")) {
+ unit_name = DEFAULT_UNIT_NAME;
+ }
+ auto equal_dist = Inkscape::Util::Quantity::convert(p.getDistributionDistance(), "px", unit_name);
+ Glib::ustring distance = Glib::ustring::format(std::fixed, std::setprecision(1), std::noshowpoint, scale*equal_dist);
+
+ switch (p.getTarget()) {
+ case SNAPTARGET_DISTRIBUTION_Y:
+ case SNAPTARGET_DISTRIBUTION_X:
+ case SNAPTARGET_DISTRIBUTION_RIGHT:
+ case SNAPTARGET_DISTRIBUTION_LEFT:
+ case SNAPTARGET_DISTRIBUTION_UP:
+ case SNAPTARGET_DISTRIBUTION_DOWN: {
+ Geom::Point p1, p2;
+ Inkscape::CanvasItemCurve *point1, *point2;
+
+ for (auto it = p.getBBoxes().begin(); it + 1 != p.getBBoxes().end(); it++) {
+ switch (p.getTarget()) {
+ case SNAPTARGET_DISTRIBUTION_RIGHT:
+ case SNAPTARGET_DISTRIBUTION_LEFT:
+ case SNAPTARGET_DISTRIBUTION_X: {
+ auto [y, sign] = get_y_and_sign(*it, *std::next(it), 5/_desktop->current_zoom());
+ p1 = Geom::Point(it->max().x() + line_offset, y);
+ p2 = Geom::Point(std::next(it)->min().x() - line_offset, y);
+ text_pos = (p1 + p2)/2 + _desktop->w2d(Geom::Point(0, sign*text_offset));
+
+ point1 = make_stub_line_v(p1);
+ point2 = make_stub_line_v(p2);
+ break;
+ }
+
+ case SNAPTARGET_DISTRIBUTION_DOWN:
+ case SNAPTARGET_DISTRIBUTION_UP:
+ case SNAPTARGET_DISTRIBUTION_Y: {
+ auto [x, sign] = get_x_and_sign(*it, *std::next(it), 5/_desktop->current_zoom());
+ p1 = Geom::Point(x, it->max().y() + line_offset);
+ p2 = Geom::Point(x, std::next(it)->min().y() - line_offset);
+ text_pos = (p1 + p2)/2 + _desktop->w2d(Geom::Point(sign*text_offset, 0));
+
+ point1 = make_stub_line_h(p1);
+ point2 = make_stub_line_h(p2);
+ break;
+ }
+ }
+
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(point1, 0));
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(point2, 0));
+
+ auto line1 = new Inkscape::CanvasItemCurve(_desktop->getCanvasTemp(), p1, p2);
+ line1->set_stroke(color);
+ line1->set_width(2);
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(line1, 0));
+
+ if (show_distance) {
+ auto text = new Inkscape::CanvasItemText(_desktop->getCanvasTemp(), text_pos, distance);
+ text->set_fontsize(fontsize);
+ text->set_fill(text_fill);
+ text->set_background(text_bg);
+ text->set_bg_radius(DISTANCE_BG_RADIUS);
+ text->set_anchor({0.5, 0.5});
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(text, 0));
+ }
+ }
+ break;
+ }
+ case SNAPTARGET_DISTRIBUTION_XY: {
+ Geom::Point p1, p2;
+ Inkscape::CanvasItemCurve *point1, *point2;
+
+ auto equal_dist2 = Inkscape::Util::Quantity::convert(p.getDistributionDistance2(), "px", unit_name);
+ Glib::ustring distance2 = Glib::ustring::format(std::fixed, std::setprecision(1), std::noshowpoint, scale*equal_dist2);
+
+ for (auto it = p.getBBoxes().begin(); it + 1 != p.getBBoxes().end(); it++) {
+ auto [y, sign] = get_y_and_sign(*it, *std::next(it), 5/_desktop->current_zoom());
+ p1 = Geom::Point(it->max().x() + line_offset, y);
+ p2 = Geom::Point(std::next(it)->min().x() - line_offset, y);
+ text_pos = (p1 + p2)/2 + _desktop->w2d(Geom::Point(0, sign*text_offset));
+
+ point1 = make_stub_line_v(p1);
+ point2 = make_stub_line_v(p2);
+
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(point1, 0));
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(point2, 0));
+
+ auto line1 = new Inkscape::CanvasItemCurve(_desktop->getCanvasTemp(), p1, p2);
+ line1->set_stroke(color);
+ line1->set_width(2);
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(line1, 0));
+
+ if (show_distance) {
+ auto text = new Inkscape::CanvasItemText(_desktop->getCanvasTemp(), text_pos, distance);
+ text->set_fontsize(fontsize);
+ text->set_fill(text_fill);
+ text->set_background(text_bg);
+ text->set_bg_radius(DISTANCE_BG_RADIUS);
+ text->set_anchor({0.5, 0.5});
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(text, 0));
+ }
+ }
+
+ for (auto it = p.getBBoxes2().begin(); it + 1 != p.getBBoxes2().end(); it++) {
+ auto [x, sign] = get_x_and_sign(*it, *std::next(it), 5/_desktop->current_zoom());
+ p1 = Geom::Point(x, it->max().y() + line_offset);
+ p2 = Geom::Point(x, std::next(it)->min().y() - line_offset);
+ text_pos = (p1 + p2)/2 + _desktop->w2d(Geom::Point(sign*text_offset, 0));
+
+ point1 = make_stub_line_h(p1);
+ point2 = make_stub_line_h(p2);
+
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(point1, 0));
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(point2, 0));
+
+ auto line1 = new Inkscape::CanvasItemCurve(_desktop->getCanvasTemp(), p1, p2);
+ line1->set_stroke(color);
+ line1->set_width(2);
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(line1, 0));
+
+ if (show_distance) {
+ auto text = new Inkscape::CanvasItemText(_desktop->getCanvasTemp(), text_pos, distance2);
+ text->set_fontsize(fontsize);
+ text->set_fill(text_fill);
+ text->set_background(text_bg);
+ text->set_bg_radius(DISTANCE_BG_RADIUS);
+ text->set_anchor({0.5, 0.5});
+ _distribution_snap_indicators.push_back(_desktop->add_temporary_canvasitem(text, 0));
+ }
+ }
+
+ break;
+ }
+ }
+}
+
+} //namespace Display
+} /* namespace Inkscape */
+
+
+/*
+ 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=4:softtabstop=4 :
diff --git a/src/display/control/snap-indicator.h b/src/display/control/snap-indicator.h
new file mode 100644
index 0000000..ca4721b
--- /dev/null
+++ b/src/display/control/snap-indicator.h
@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef INKSCAPE_DISPLAY_SNAP_INDICATOR_H
+#define INKSCAPE_DISPLAY_SNAP_INDICATOR_H
+
+/**
+ * @file
+ * Provides a class that shows a temporary indicator on the canvas of where the snap was, and what kind of snap
+ */
+/*
+ * Authors:
+ * Johan Engelen
+ * Diederik van Lierop
+ *
+ * Copyright (C) Johan Engelen 2008 <j.b.c.engelen@utwente.nl>
+ * Copyright (C) Diederik van Lierop 2010 <mail@diedenrezi.nl>
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "snap-enums.h"
+#include "snapped-point.h"
+#include "display/control/canvas-item-curve.h"
+
+#include <glib.h>
+#include <glibmm/i18n.h>
+
+class SPDesktop;
+
+namespace Inkscape {
+namespace Display {
+
+class TemporaryItem;
+
+class SnapIndicator {
+public:
+ SnapIndicator(SPDesktop *desktop);
+ virtual ~SnapIndicator();
+
+ void set_new_snaptarget(Inkscape::SnappedPoint const &p, bool pre_snap = false);
+ void remove_snaptarget(bool only_if_presnap = false);
+
+ void set_new_snapsource(Inkscape::SnapCandidatePoint const &p);
+ void remove_snapsource();
+
+ void set_new_debugging_point(Geom::Point const &p);
+ void remove_debugging_points();
+
+protected:
+ TemporaryItem *_snaptarget;
+ TemporaryItem *_snaptarget_tooltip;
+ TemporaryItem *_snaptarget_bbox;
+ TemporaryItem *_snapsource;
+
+ std::list<TemporaryItem *> _alignment_snap_indicators;
+ std::list<TemporaryItem *> _distribution_snap_indicators;
+ std::list<TemporaryItem *> _debugging_points;
+ bool _snaptarget_is_presnap;
+ SPDesktop *_desktop;
+
+private:
+ SnapIndicator(const SnapIndicator&) = delete;
+ SnapIndicator& operator=(const SnapIndicator&) = delete;
+
+ void make_distribution_indicators(SnappedPoint const &p, double fontsize, double scale);
+ void make_alignment_indicator(Geom::Point const &p1, Geom::Point const &p2, guint32 color, double fontsize, double scale);
+ guint32 get_guide_color(SnapTargetType t);
+ Inkscape::CanvasItemCurve* make_stub_line_h(Geom::Point const &p);
+ Inkscape::CanvasItemCurve* make_stub_line_v(Geom::Point const &p);
+};
+
+} //namespace Display
+} //namespace Inkscape
+
+#endif
+
+/*
+ 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 :