Adding upstream version 1.2.2.upstream/1.2.2upstream

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

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 :