Adding upstream version 1.3+ds.upstream/1.3+dsupstream

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

16 files changed, 5072 insertions, 0 deletions

diff --git a/src/widgets/CMakeLists.txt b/src/widgets/CMakeLists.txt
new file mode 100644
index 0000000..3701fc5
--- /dev/null
+++ b/src/widgets/CMakeLists.txt
@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+set(widgets_SRC
+	desktop-widget.cpp
+	paintdef.cpp
+	sp-attribute-widget.cpp
+	sp-xmlview-tree.cpp
+	spw-utilities.cpp
+	toolbox.cpp
+
+	# -------
+	# Headers
+	desktop-widget.h
+	paintdef.h
+	sp-attribute-widget.h
+	sp-xmlview-tree.h
+	spw-utilities.h
+	toolbox.h
+	widget-sizes.h
+)
+
+add_inkscape_source("${widgets_SRC}")
diff --git a/src/widgets/README b/src/widgets/README
new file mode 100644
index 0000000..b1c905a
--- /dev/null
+++ b/src/widgets/README
@@ -0,0 +1,10 @@
+
+
+This directory contains widgets written in 'C'.
+
+To do:
+
+* Replace 'C' widgets by 'C++' widgets.
+* Temporary move to 'ui/widgets/legacy'.
+
+
diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
new file mode 100644
index 0000000..edb4200
--- /dev/null
+++ b/src/widgets/desktop-widget.cpp
@@ -0,0 +1,1937 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** \file
+ * Desktop widget implementation
+ */
+/* Authors:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   MenTaLguY <mental@rydia.net>
+ *   bulia byak <buliabyak@users.sf.net>
+ *   Ralf Stephan <ralf@ark.in-berlin.de>
+ *   John Bintz <jcoswell@coswellproductions.org>
+ *   Johan Engelen <j.b.c.engelen@ewi.utwente.nl>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *   Abhishek Sharma
+ *
+ * Copyright (C) 2007 Johan Engelen
+ * Copyright (C) 2006 John Bintz
+ * Copyright (C) 2004 MenTaLguY
+ * Copyright (C) 1999-2002 Lauris Kaplinski
+ * Copyright (C) 2000-2001 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"  // only include where actually required!
+#endif
+
+#include <2geom/rect.h>
+
+#include "attributes.h"
+#include "cms-system.h"
+#include "conn-avoid-ref.h"
+#include "desktop-events.h"
+#include "desktop-widget.h"
+#include "desktop.h"
+#include "document-undo.h"
+#include "ege-color-prof-tracker.h"
+#include "enums.h"
+#include "file.h"
+#include "inkscape-application.h"
+#include "inkscape-window.h"
+#include "inkscape-version.h"
+
+#include "display/control/canvas-item-drawing.h"
+#include "display/control/canvas-item-guideline.h"
+
+#include "extension/db.h"
+
+#include "object/sp-image.h"
+#include "object/sp-namedview.h"
+#include "object/sp-root.h"
+#include "object/sp-grid.h"
+
+#include "ui/shortcuts.h"
+#include "ui/dialog/swatches.h"
+#include "ui/icon-loader.h"
+#include "ui/icon-names.h"
+#include "ui/monitor.h"   // Monitor aspect ratio
+#include "ui/dialog/dialog-container.h"
+#include "ui/dialog/dialog-multipaned.h"
+#include "ui/dialog/dialog-window.h"
+#include "ui/tools/box3d-tool.h"
+#include "ui/tools/text-tool.h"
+#include "ui/util.h"
+#include "ui/widget/canvas.h"
+#include "ui/widget/canvas-grid.h"
+#include "ui/widget/combo-tool-item.h"
+#include "ui/widget/ink-ruler.h"
+#include "ui/widget/layer-selector.h"
+#include "ui/widget/page-selector.h"
+#include "ui/widget/selected-style.h"
+#include "ui/widget/spin-button-tool-item.h"
+#include "ui/widget/unit-tracker.h"
+#include "ui/themes.h"
+
+#include "util/units.h"
+
+// We're in the "widgets" directory, so no need to explicitly prefix these:
+#include "spw-utilities.h"
+#include "toolbox.h"
+#include "widget-sizes.h"
+
+#include "ui/widget/color-palette.h"
+#include "widgets/paintdef.h"
+
+using Inkscape::DocumentUndo;
+using Inkscape::UI::Dialog::DialogContainer;
+using Inkscape::UI::Dialog::DialogMultipaned;
+using Inkscape::UI::Dialog::DialogWindow;
+using Inkscape::UI::Widget::UnitTracker;
+using Inkscape::UI::ToolboxFactory;
+using Inkscape::Util::unit_table;
+
+
+//---------------------------------------------------------------------
+/* SPDesktopWidget */
+
+class CMSPrefWatcher {
+public:
+    CMSPrefWatcher() :
+        _dpw(*this),
+        _tracker(ege_color_prof_tracker_new(nullptr))
+    {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        g_signal_connect( G_OBJECT(_tracker), "modified", G_CALLBACK(hook), this );
+        prefs->addObserver(_dpw);
+    }
+    virtual ~CMSPrefWatcher() = default;
+
+    //virtual void notify(PrefValue &);
+    void add( SPDesktopWidget* dtw ) {
+        _widget_list.push_back(dtw);
+    }
+    void remove( SPDesktopWidget* dtw ) {
+        _widget_list.remove(dtw);
+    }
+
+private:
+    static void hook(EgeColorProfTracker *tracker, gint b, CMSPrefWatcher *watcher);
+
+    class DisplayProfileWatcher : public Inkscape::Preferences::Observer {
+    public:
+        DisplayProfileWatcher(CMSPrefWatcher &pw) : Observer("/options/displayprofile"), _pw(pw) {}
+        void notify(Inkscape::Preferences::Entry const &/*val*/) override {
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            _pw._setCmsSensitive(!prefs->getString("/options/displayprofile/uri").empty());
+        }
+    private:
+        CMSPrefWatcher &_pw;
+    };
+
+    DisplayProfileWatcher _dpw;
+
+    void _setCmsSensitive(bool value);
+
+    std::list<SPDesktopWidget*> _widget_list;
+    EgeColorProfTracker *_tracker;
+
+    friend class DisplayProfileWatcher;
+};
+
+void CMSPrefWatcher::hook(EgeColorProfTracker * /*tracker*/, gint monitor, CMSPrefWatcher * /*watcher*/)
+{
+    unsigned char* buf = nullptr;
+    guint len = 0;
+
+    ege_color_prof_tracker_get_profile_for( monitor, reinterpret_cast<gpointer*>(&buf), &len );
+    Glib::ustring id = Inkscape::CMSSystem::setDisplayPer( buf, len, monitor );
+}
+
+void CMSPrefWatcher::_setCmsSensitive(bool enabled)
+{
+    for ( auto dtw : _widget_list ) {
+        auto cms_adj = dtw->get_canvas_grid()->GetCmsAdjust();
+        if ( cms_adj->get_sensitive() != enabled ) {
+            dtw->cms_adjust_set_sensitive(enabled);
+        }
+    }
+}
+
+static CMSPrefWatcher* watcher = nullptr;
+
+SPDesktopWidget::SPDesktopWidget(InkscapeWindow* inkscape_window)
+    : window (inkscape_window)
+{
+    auto *const dtw = this;
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    /* Main table */
+    dtw->_vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
+    dtw->_vbox->set_name("DesktopMainTable");
+    dtw->add(*dtw->_vbox);
+
+    /* Status bar */
+    dtw->_statusbar = Gtk::manage(new Gtk::Box());
+    dtw->_statusbar->set_name("DesktopStatusBar");
+    dtw->_vbox->pack_end(*dtw->_statusbar, false, true);
+
+    /* Swatch Bar */
+    dtw->_panels = Gtk::manage(new Inkscape::UI::Dialog::SwatchesPanel("/embedded/swatches"));
+    dtw->_panels->set_vexpand(false);
+    dtw->_vbox->pack_end(*dtw->_panels, false, true);
+
+    /* DesktopHBox (Vertical toolboxes, canvas) */
+    dtw->_hbox = Gtk::manage(new Gtk::Box());
+    dtw->_hbox->set_name("DesktopHbox");
+
+    dtw->_tbbox = Gtk::manage(new Gtk::Paned(Gtk::ORIENTATION_HORIZONTAL));
+    dtw->_tbbox->set_name("ToolboxCanvasPaned");
+    dtw->_hbox->pack_start(*dtw->_tbbox, true, true);
+
+    dtw->_vbox->pack_end(*dtw->_hbox, true, true);
+
+    dtw->_top_toolbars = Gtk::make_managed<Gtk::Grid>();
+    dtw->_top_toolbars->set_name("TopToolbars");
+    dtw->_vbox->pack_end(*dtw->_top_toolbars, false, true);
+
+    /* Toolboxes */
+    dtw->aux_toolbox = ToolboxFactory::createAuxToolbox();
+
+    dtw->snap_toolbox = ToolboxFactory::createSnapToolbox();
+
+    dtw->commands_toolbox = ToolboxFactory::createCommandsToolbox();
+    auto cmd = Glib::wrap(dtw->commands_toolbox);
+    dtw->_top_toolbars->attach(*cmd, 0, 0);
+
+    dtw->_top_toolbars->attach(*Glib::wrap(dtw->aux_toolbox), 0, 1);
+
+    dtw->tool_toolbox = ToolboxFactory::createToolToolbox(inkscape_window);
+    ToolboxFactory::setOrientation( dtw->tool_toolbox, GTK_ORIENTATION_VERTICAL );
+    dtw->_tbbox->pack1(*Glib::wrap(dtw->tool_toolbox), false, true);
+
+    _tb_snap_pos = prefs->createObserver("/toolbox/simplesnap", sigc::mem_fun(*this, &SPDesktopWidget::repack_snaptoolbar));
+    repack_snaptoolbar();
+
+    auto tbox_width = prefs->getEntry("/toolbox/tools/width");
+    if (tbox_width.isValid()) {
+        _tbbox->set_position(tbox_width.getIntLimited(32, 8, 500));
+    }
+
+    auto set_visible_buttons = [=](GtkWidget* tb) {
+        int buttons_before_separator = 0;
+        Gtk::Widget* last_sep = nullptr;
+        Gtk::FlowBox* last_box = nullptr;
+        sp_traverse_widget_tree(Glib::wrap(tb), [&](Gtk::Widget* widget) {
+            if (auto flowbox = dynamic_cast<Gtk::FlowBox*>(widget)) {
+                flowbox->show();
+                flowbox->set_no_show_all();
+                flowbox->set_max_children_per_line(1);
+                last_box = flowbox;
+            }
+            else if (auto btn = dynamic_cast<Gtk::Button*>(widget)) {
+                auto name = sp_get_action_target(widget);
+                auto show = prefs->getBool(ToolboxFactory::get_tool_visible_buttons_path(name), true);
+                auto parent = btn->get_parent();
+                if (show) {
+                    parent->show();
+                    ++buttons_before_separator;
+                    // keep the max_children up to date improves display.
+                    last_box->set_max_children_per_line(buttons_before_separator);
+                    last_sep = nullptr;
+                }
+                else {
+                    parent->hide();
+                }
+            }
+            else if (auto sep = dynamic_cast<Gtk::Separator*>(widget)) {
+                if (buttons_before_separator <= 0) {
+                    sep->hide();
+                }
+                else {
+                    sep->show();
+                    buttons_before_separator = 0;
+                    last_sep = sep;
+                }
+            }
+            return false;
+        });
+        if (last_sep) {
+            // hide trailing separator
+            last_sep->hide();
+        }
+    };
+    auto set_toolbar_prefs = [=]() {
+        int min = ToolboxFactory::min_pixel_size;
+        int max = ToolboxFactory::max_pixel_size;
+        int s = prefs->getIntLimited(ToolboxFactory::tools_icon_size, min, min, max);
+        Inkscape::UI::set_icon_sizes(tool_toolbox, s);
+    };
+
+    // watch for changes
+    _tb_icon_sizes1 = prefs->createObserver(ToolboxFactory::tools_icon_size,    [=]() { set_toolbar_prefs(); });
+    _tb_icon_sizes2 = prefs->createObserver(ToolboxFactory::ctrlbars_icon_size, [=]() { apply_ctrlbar_settings(); });
+    _tb_visible_buttons = prefs->createObserver(ToolboxFactory::tools_visible_buttons, [=]() { set_visible_buttons(tool_toolbox); });
+
+    // restore preferences
+    set_toolbar_prefs();
+    apply_ctrlbar_settings();
+    set_visible_buttons(tool_toolbox);
+
+    /* Canvas Grid (canvas, rulers, scrollbars, etc.) */
+    // desktop widgets owns it
+    _canvas_grid = new Inkscape::UI::Widget::CanvasGrid(this);
+
+    /* Canvas */
+    dtw->_canvas = _canvas_grid->GetCanvas();
+    dtw->_canvas->set_cms_active(prefs->getBool("/options/displayprofile/enable"));
+
+    _ds_sticky_zoom = prefs->createObserver("/options/stickyzoom/value", [=]() { sticky_zoom_updated(); });
+    sticky_zoom_updated();
+
+    /* Dialog Container */
+    _container = Gtk::manage(new DialogContainer(inkscape_window));
+    _columns = _container->get_columns();
+    _columns->set_dropzone_sizes(2, -1);
+    dtw->_tbbox->pack2(*_container, true, true);
+
+    _canvas_grid->set_hexpand(true);
+    _canvas_grid->set_vexpand(true);
+    _columns->append(_canvas_grid);
+
+    // --------------- Status Tool Bar ------------------//
+
+    // Selected Style (Fill/Stroke/Opacity)
+    dtw->_selected_style = Gtk::manage(new Inkscape::UI::Widget::SelectedStyle(true));
+    dtw->_statusbar->pack_start(*dtw->_selected_style, false, false);
+    _selected_style->show_all();
+    _selected_style->set_no_show_all();
+
+    // Layer Selector
+    _layer_selector = Gtk::manage(new Inkscape::UI::Widget::LayerSelector(nullptr));
+    // separate layer selector buttons from status text
+    auto vseparator = Gtk::make_managed<Gtk::Separator>(Gtk::ORIENTATION_VERTICAL);
+    vseparator->set_margin_end(6);
+    vseparator->set_margin_top(6);
+    vseparator->set_margin_bottom(6);
+    _layer_selector->pack_end(*vseparator);
+    _layer_selector->show_all();
+    _layer_selector->set_no_show_all();
+    dtw->_statusbar->pack_start(*_layer_selector, false, false, 1);
+
+    // Select Status
+    dtw->_select_status = Gtk::manage(new Gtk::Label());
+    dtw->_select_status->set_name("SelectStatus");
+    dtw->_select_status->set_ellipsize(Pango::ELLIPSIZE_END);
+    dtw->_select_status->set_line_wrap(true);
+    dtw->_select_status->set_lines(2);
+    dtw->_select_status->set_halign(Gtk::ALIGN_START);
+    dtw->_select_status->set_size_request(1, -1);
+
+    // Display the initial welcome message in the statusbar
+    dtw->_select_status->set_markup(_("<b>Welcome to Inkscape!</b> Use shape or freehand tools to create objects; use selector (arrow) to move or transform them."));
+
+    dtw->_statusbar->pack_start(*dtw->_select_status, true, true);
+
+    dtw->_zoom_status_box = Gtk::make_managed<Gtk::Box>();
+    // Zoom status spinbutton ---------------
+    auto zoom_adj = Gtk::Adjustment::create(100.0, log(SP_DESKTOP_ZOOM_MIN)/log(2), log(SP_DESKTOP_ZOOM_MAX)/log(2), 0.1);
+    dtw->_zoom_status = Gtk::manage(new Inkscape::UI::Widget::SpinButton(zoom_adj));
+
+    dtw->_zoom_status->set_defocus_widget(dtw->_canvas);
+    dtw->_zoom_status->set_tooltip_text(_("Zoom"));
+    dtw->_zoom_status->set_size_request(STATUS_ZOOM_WIDTH, -1);
+    dtw->_zoom_status->set_width_chars(6);
+    dtw->_zoom_status->set_numeric(false);
+    dtw->_zoom_status->set_update_policy(Gtk::UPDATE_ALWAYS);
+
+    // Callbacks
+    dtw->_zoom_status_input_connection  = dtw->_zoom_status->signal_input().connect(sigc::mem_fun(*dtw, &SPDesktopWidget::zoom_input));
+    dtw->_zoom_status_output_connection = dtw->_zoom_status->signal_output().connect(sigc::mem_fun(*dtw, &SPDesktopWidget::zoom_output));
+    dtw->_zoom_status_value_changed_connection = dtw->_zoom_status->signal_value_changed().connect(sigc::mem_fun(*dtw, &SPDesktopWidget::zoom_value_changed));
+    dtw->_zoom_status_populate_popup_connection = dtw->_zoom_status->signal_populate_popup().connect(sigc::mem_fun(*dtw, &SPDesktopWidget::zoom_populate_popup));
+
+    // Style
+    auto css_provider_spinbutton = Gtk::CssProvider::create();
+    css_provider_spinbutton->load_from_data("* { padding-left: 2px; padding-right: 2px; padding-top: 0px; padding-bottom: 0px;}");  // Shouldn't this be in a style sheet? Used also by rotate.
+
+    dtw->_zoom_status->set_name("ZoomStatus");
+    auto context_zoom = dtw->_zoom_status->get_style_context();
+    context_zoom->add_provider(css_provider_spinbutton, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+    dtw->_rotation_status_box = Gtk::make_managed<Gtk::Box>();
+    dtw->_rotation_status_box->set_margin_start(10);
+    // Rotate status spinbutton ---------------
+    auto rotation_adj = Gtk::Adjustment::create(0, -360.0, 360.0, 1.0);
+
+    dtw->_rotation_status = Gtk::manage(new Inkscape::UI::Widget::SpinButton(rotation_adj));
+
+    // FIXME: This is a bit of a hack, to avoid the ExpressionEvaluator struggling to parse the
+    //        degree symbol.  It would be better to improve ExpressionEvaluator so it copes
+    dtw->_rotation_status->set_dont_evaluate(true);
+
+    dtw->_rotation_status->set_defocus_widget(dtw->_canvas);
+    dtw->_rotation_status->set_tooltip_text(_("Rotation. (Also Ctrl+Shift+Scroll)"));
+    dtw->_rotation_status->set_size_request(STATUS_ROTATION_WIDTH, -1);
+    dtw->_rotation_status->set_width_chars(7);
+    dtw->_rotation_status->set_numeric(false);
+    dtw->_rotation_status->set_digits(2);
+    dtw->_rotation_status->set_increments(1.0, 15.0);
+    dtw->_rotation_status->set_update_policy(Gtk::UPDATE_ALWAYS);
+
+    // Callbacks
+    dtw->_rotation_status_output_connection = dtw->_rotation_status->signal_output().connect(sigc::mem_fun(*dtw, &SPDesktopWidget::rotation_output));
+    dtw->_rotation_status_value_changed_connection = dtw->_rotation_status->signal_value_changed().connect(sigc::mem_fun(*dtw, &SPDesktopWidget::rotation_value_changed));
+    dtw->_rotation_status_populate_popup_connection = dtw->_rotation_status->signal_populate_popup().connect(sigc::mem_fun(*dtw, &SPDesktopWidget::rotation_populate_popup));
+
+    // Style
+    dtw->_rotation_status->set_name("RotationStatus");
+    auto context_rotation = dtw->_rotation_status->get_style_context();
+    context_rotation->add_provider(css_provider_spinbutton, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+    // Cursor coordinates
+    dtw->_coord_status = Gtk::manage(new Gtk::Grid());
+    dtw->_coord_status->set_name("CoordinateAndZStatus");
+    dtw->_coord_status->set_row_spacing(0);
+    dtw->_coord_status->set_column_spacing(10);
+    dtw->_coord_status->set_margin_end(10);
+    auto sep = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_VERTICAL));
+    sep->set_name("CoordinateSeparator");
+    dtw->_coord_status->attach(*sep, 0, 0, 1, 2);
+
+    dtw->_coord_status->set_tooltip_text(_("Cursor coordinates"));
+    auto label_x = Gtk::manage(new Gtk::Label(_("X:")));
+    auto label_y = Gtk::manage(new Gtk::Label(_("Y:")));
+    label_x->set_halign(Gtk::ALIGN_START);
+    label_y->set_halign(Gtk::ALIGN_START);
+    dtw->_coord_status->attach(*label_x, 1, 0, 1, 1);
+    dtw->_coord_status->attach(*label_y, 1, 1, 1, 1);
+    dtw->_coord_status_x = Gtk::manage(new Gtk::Label());
+    dtw->_coord_status_y = Gtk::manage(new Gtk::Label());
+    dtw->_coord_status_x->set_name("CoordinateStatusX");
+    dtw->_coord_status_y->set_name("CoordinateStatusY");
+    dtw->_coord_status_x->set_markup("   0.00 ");
+    dtw->_coord_status_y->set_markup("   0.00 ");
+
+    // TRANSLATORS: Abbreviation for canvas zoom level
+    auto label_z = Gtk::manage(new Gtk::Label(C_("canvas", "Z:")));
+    label_z->set_name("ZLabel");
+    // TRANSLATORS: Abbreviation for canvas rotation
+    auto label_r = Gtk::manage(new Gtk::Label(C_("canvas", "R:")));
+    label_r->set_name("RLabel");
+
+    dtw->_coord_status_x->set_halign(Gtk::ALIGN_END);
+    dtw->_coord_status_y->set_halign(Gtk::ALIGN_END);
+    dtw->_coord_status->attach(*dtw->_coord_status_x, 2, 0, 1, 1);
+    dtw->_coord_status->attach(*dtw->_coord_status_y, 2, 1, 1, 1);
+    dtw->_coord_status->show_all();
+    dtw->_coord_status->set_no_show_all();
+
+    dtw->_zoom_status_box->pack_start(*label_z, true, true);
+    dtw->_zoom_status_box->pack_end(*dtw->_zoom_status, true, true);
+    dtw->_zoom_status_box->show_all();
+
+    dtw->_rotation_status_box->pack_start(*label_r, true, true);
+    dtw->_rotation_status_box->pack_end(*dtw->_rotation_status, true, true);
+    dtw->_rotation_status_box->show_all();
+    dtw->_rotation_status_box->set_no_show_all();
+
+    dtw->_statusbar->pack_end(*dtw->_rotation_status_box, false, false);
+    dtw->_statusbar->pack_end(*dtw->_zoom_status_box, false, false);
+    dtw->_statusbar->pack_end(*dtw->_coord_status, false, false);
+
+    update_statusbar_visibility();
+
+    _statusbar_preferences_observer = prefs->createObserver("/statusbar/visibility", [=]() {
+        update_statusbar_visibility();
+    });
+
+    // --------------- Color Management ---------------- //
+    dtw->_tracker = ege_color_prof_tracker_new(GTK_WIDGET(_layer_selector->gobj()));
+    bool fromDisplay = prefs->getBool( "/options/displayprofile/from_display");
+    if ( fromDisplay ) {
+        auto id = Inkscape::CMSSystem::getDisplayId(0);
+        dtw->_canvas->set_cms_key(id);
+        dtw->cms_adjust_set_sensitive(!id.empty());
+    }
+    g_signal_connect( G_OBJECT(dtw->_tracker), "changed", G_CALLBACK(SPDesktopWidget::color_profile_event), dtw );
+
+    // ------------------ Finish Up -------------------- //
+    dtw->_vbox->show_all();
+    dtw->_canvas_grid->ShowCommandPalette(false);
+
+    dtw->_canvas->grab_focus();
+}
+
+void SPDesktopWidget::apply_ctrlbar_settings() {
+    Inkscape::Preferences* prefs = Inkscape::Preferences::get();
+    int min = ToolboxFactory::min_pixel_size;
+    int max = ToolboxFactory::max_pixel_size;
+    int size = prefs->getIntLimited(ToolboxFactory::ctrlbars_icon_size, min, min, max);
+    Inkscape::UI::set_icon_sizes(snap_toolbox, size);
+    Inkscape::UI::set_icon_sizes(commands_toolbox, size);
+    Inkscape::UI::set_icon_sizes(aux_toolbox, size);
+}
+
+void SPDesktopWidget::update_statusbar_visibility() {
+    auto prefs = Inkscape::Preferences::get();
+    Glib::ustring path("/statusbar/visibility/");
+
+    _coord_status->set_visible(prefs->getBool(path + "coordinates", true));
+    _rotation_status_box->set_visible(prefs->getBool(path + "rotation", true));
+    _layer_selector->set_visible(prefs->getBool(path + "layer", true));
+    _selected_style->set_visible(prefs->getBool(path + "style", true));
+}
+
+void
+SPDesktopWidget::setMessage (Inkscape::MessageType type, const gchar *message)
+{
+    _select_status->set_markup(message ? message : "");
+
+    // make sure the important messages are displayed immediately!
+    if (type == Inkscape::IMMEDIATE_MESSAGE && _select_status->get_is_drawable()) {
+        _select_status->queue_draw();
+    }
+
+    _select_status->set_tooltip_text(_select_status->get_text());
+}
+
+/**
+ * Called before SPDesktopWidget destruction.
+ * (Might be called more than once)
+ */
+void
+SPDesktopWidget::on_unrealize()
+{
+    auto dtw = this;
+
+    if (_tbbox) {
+        Inkscape::Preferences::get()->setInt("/toolbox/tools/width", _tbbox->get_position());
+    }
+
+    if (dtw->desktop) {
+        if ( watcher ) {
+            watcher->remove(dtw);
+        }
+
+        for (auto &conn : dtw->_connections) {
+            conn.disconnect();
+        }
+
+        // Canvas
+        dtw->_canvas->set_drawing(nullptr); // Ensures deactivation
+        dtw->_canvas->set_desktop(nullptr); // Todo: Remove desktop dependency.
+
+        // Zoom
+        dtw->_zoom_status_input_connection.disconnect();
+        dtw->_zoom_status_output_connection.disconnect();
+        g_signal_handlers_disconnect_by_data(G_OBJECT(dtw->_zoom_status->gobj()), dtw->_zoom_status->gobj());
+        dtw->_zoom_status_value_changed_connection.disconnect();
+        dtw->_zoom_status_populate_popup_connection.disconnect();
+
+        // Rotation
+        dtw->_rotation_status_input_connection.disconnect();
+        dtw->_rotation_status_output_connection.disconnect();
+        g_signal_handlers_disconnect_by_data(G_OBJECT(dtw->_rotation_status->gobj()), dtw->_rotation_status->gobj());
+        dtw->_rotation_status_value_changed_connection.disconnect();
+        dtw->_rotation_status_populate_popup_connection.disconnect();
+
+        dtw->_panels->setDesktop(nullptr);
+
+        delete _container; // will unrealize dtw->_canvas
+
+        _layer_selector->setDesktop(nullptr);
+        INKSCAPE.remove_desktop(dtw->desktop); // clears selection and event_context
+        dtw->modified_connection.disconnect();
+        dtw->desktop->destroy();
+        Inkscape::GC::release (dtw->desktop);
+        dtw->desktop = nullptr;
+    }
+
+    parent_type::on_unrealize();
+}
+
+SPDesktopWidget::~SPDesktopWidget() {
+    delete _canvas_grid;
+}
+
+/**
+ * Set the title in the desktop-window (if desktop has an own window).
+ *
+ * The title has form file name: desktop number - Inkscape.
+ * The desktop number is only shown if it's 2 or higher,
+ */
+void
+SPDesktopWidget::updateTitle(gchar const* uri)
+{
+    if (window) {
+
+        SPDocument *doc = this->desktop->doc();
+        auto namedview = doc->getNamedView();
+
+        std::string Name;
+        if (doc->isModifiedSinceSave()) {
+            Name += "*";
+        }
+
+        Name += uri;
+
+        if (namedview->viewcount > 1) {
+            Name += ": ";
+            Name += std::to_string(namedview->viewcount);
+        }
+        Name += " (";
+
+        auto render_mode = desktop->getCanvas()->get_render_mode();
+        auto color_mode  = desktop->getCanvas()->get_color_mode();
+
+        if (render_mode == Inkscape::RenderMode::OUTLINE) {
+            Name += N_("outline");
+        } else if (render_mode == Inkscape::RenderMode::NO_FILTERS) {
+            Name += N_("no filters");
+        } else if (render_mode == Inkscape::RenderMode::VISIBLE_HAIRLINES) {
+            Name += N_("enhance thin lines");
+        } else if (render_mode == Inkscape::RenderMode::OUTLINE_OVERLAY) {
+            Name += N_("outline overlay");
+        }
+
+        if (color_mode != Inkscape::ColorMode::NORMAL &&
+            render_mode != Inkscape::RenderMode::NORMAL) {
+                Name += ", ";
+        }
+
+        if (color_mode == Inkscape::ColorMode::GRAYSCALE) {
+            Name += N_("grayscale");
+        } else if (color_mode == Inkscape::ColorMode::PRINT_COLORS_PREVIEW) {
+            Name += N_("print colors preview");
+        }
+
+        if (*Name.rbegin() == '(') {  // Can not use C++11 .back() or .pop_back() with ustring!
+            Name.erase(Name.size() - 2);
+        } else {
+            Name += ")";
+        }
+
+        Name += " - Inkscape";
+
+        // Name += " (";
+        // Name += Inkscape::version_string;
+        // Name += ")";
+
+        window->set_title (Name);
+    }
+}
+
+DialogContainer *SPDesktopWidget::getDialogContainer()
+{
+    return _container;
+}
+
+void SPDesktopWidget::showNotice(Glib::ustring const &msg, unsigned timeout)
+{
+    _canvas_grid->showNotice(msg, timeout);
+}
+
+/**
+ * Callback to realize desktop widget.
+ */
+void SPDesktopWidget::on_realize()
+{
+    SPDesktopWidget *dtw = this;
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    parent_type::on_realize();
+
+    Geom::Rect d = Geom::Rect::from_xywh(Geom::Point(0,0), (dtw->desktop->doc())->getDimensions());
+
+    if (d.width() < 1.0 || d.height() < 1.0) return;
+
+    dtw->desktop->set_display_area (d, 10);
+
+    dtw->updateNamedview();
+    Gtk::Container *window = get_toplevel();
+    if (window) {
+        bool dark = INKSCAPE.themecontext->isCurrentThemeDark(dynamic_cast<Gtk::Container *>(window));
+        prefs->setBool("/theme/darkTheme", dark);
+        INKSCAPE.themecontext->getChangeThemeSignal().emit();
+        INKSCAPE.themecontext->add_gtk_css(true);
+    }
+}
+
+/* This is just to provide access to common functionality from sp_desktop_widget_realize() above
+   as well as from SPDesktop::change_document() */
+void SPDesktopWidget::updateNamedview()
+{
+    // Listen on namedview modification
+    // originally (prior to the sigc++ conversion) the signal was simply
+    // connected twice rather than disconnecting the first connection
+    modified_connection.disconnect();
+
+    modified_connection = desktop->namedview->connectModified(sigc::mem_fun(*this, &SPDesktopWidget::namedviewModified));
+    namedviewModified(desktop->namedview, SP_OBJECT_MODIFIED_FLAG);
+
+    updateTitle( desktop->doc()->getDocumentName() );
+}
+
+/**
+ * Callback to handle desktop widget event.
+ */
+gint
+SPDesktopWidget::event(GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw)
+{
+    if (event->type == GDK_BUTTON_PRESS) {
+        // defocus any spinbuttons
+        dtw->_canvas->grab_focus();
+    }
+
+    if ((event->type == GDK_BUTTON_PRESS) && (event->button.button == 3)) {
+        if (event->button.state & GDK_SHIFT_MASK) {
+            dtw->desktop->getCanvasDrawing()->set_sticky(true);
+        } else {
+            dtw->desktop->getCanvasDrawing()->set_sticky(false);
+        }
+    }
+
+    {
+        // The key press/release events need to be passed to desktop handler explicitly,
+        // because otherwise the event contexts only receive key events when the mouse cursor
+        // is over the canvas. This redirection is only done for key events and only if there's no
+        // current item on the canvas, because item events and all mouse events are caught
+        // and passed on by the canvas acetate (I think). --bb
+
+        if ((event->type == GDK_KEY_PRESS || event->type == GDK_KEY_RELEASE)
+            && !dtw->_canvas->get_current_canvas_item()) {
+            return (gint)sp_desktop_root_handler (event, dtw->desktop);
+        }
+    }
+
+    return FALSE;
+}
+
+void
+SPDesktopWidget::color_profile_event(EgeColorProfTracker */*tracker*/, SPDesktopWidget *dtw)
+{
+    // Handle profile changes
+    GdkWindow *window = dtw->get_window()->gobj();
+
+    // Figure out the ID for the monitor
+    auto display = gdk_display_get_default();
+    auto monitor = gdk_display_get_monitor_at_window(display, window);
+
+    int n_monitors = gdk_display_get_n_monitors(display);
+
+    int monitorNum = -1;
+
+    // Now loop through the set of monitors and figure out whether this monitor matches
+    for (int i_monitor = 0; i_monitor < n_monitors; ++i_monitor) {
+        auto monitor_at_index = gdk_display_get_monitor(display, i_monitor);
+        if (monitor_at_index == monitor) monitorNum = i_monitor;
+    }
+
+    Glib::ustring id = Inkscape::CMSSystem::getDisplayId( monitorNum );
+    dtw->_canvas->set_cms_key(id);
+    dtw->cms_adjust_set_sensitive(!id.empty());
+}
+
+void
+SPDesktopWidget::update_guides_lock()
+{
+    bool down = _canvas_grid->GetGuideLock()->get_active();
+    auto nv   = desktop->getNamedView();
+    bool lock = nv->getLockGuides();
+
+    if (down != lock) {
+        nv->toggleLockGuides();
+        setMessage(Inkscape::NORMAL_MESSAGE, down ? _("Locked all guides") : _("Unlocked all guides"));
+    }
+}
+
+void
+SPDesktopWidget::cms_adjust_toggled()
+{
+    auto _cms_adjust = _canvas_grid->GetCmsAdjust();
+
+    bool down = _cms_adjust->get_active();
+    if ( down != _canvas->get_cms_active() ) {
+        _canvas->set_cms_active(down);
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setBool("/options/displayprofile/enable", down);
+        if (down) {
+            setMessage (Inkscape::NORMAL_MESSAGE, _("Color-managed display is <b>enabled</b> in this window"));
+        } else {
+            setMessage (Inkscape::NORMAL_MESSAGE, _("Color-managed display is <b>disabled</b> in this window"));
+        }
+    }
+}
+
+void
+SPDesktopWidget::cms_adjust_set_sensitive(bool enabled)
+{
+    _canvas_grid->GetCmsAdjust()->set_sensitive(enabled);
+}
+
+void
+SPDesktopWidget::enableInteraction()
+{
+  g_return_if_fail(_interaction_disabled_counter > 0);
+
+  _interaction_disabled_counter--;
+
+  if (_interaction_disabled_counter == 0) {
+    this->set_sensitive();
+  }
+}
+
+void
+SPDesktopWidget::disableInteraction()
+{
+  if (_interaction_disabled_counter == 0) {
+    this->set_sensitive(false);
+  }
+
+  _interaction_disabled_counter++;
+}
+
+void
+SPDesktopWidget::setCoordinateStatus(Geom::Point p)
+{
+    gchar *cstr;
+    cstr = g_strdup_printf("%7.2f", _dt2r * p[Geom::X]);
+    _coord_status_x->set_markup(cstr);
+    g_free(cstr);
+
+    cstr = g_strdup_printf("%7.2f", _dt2r * p[Geom::Y]);
+    _coord_status_y->set_markup(cstr);
+    g_free(cstr);
+}
+
+void
+SPDesktopWidget::letZoomGrabFocus()
+{
+    if (_zoom_status) _zoom_status->grab_focus();
+}
+
+void
+SPDesktopWidget::getWindowGeometry (gint &x, gint &y, gint &w, gint &h)
+{
+    if (window) {
+        window->get_size (w, h);
+        window->get_position (x, y);
+        // The get_positon is very unreliable (see Gtk docs) and will often return zero.
+        if (!x && !y) {
+            if (Glib::RefPtr<Gdk::Window> w = window->get_window()) {
+                Gdk::Rectangle rect;
+                w->get_frame_extents(rect);
+                x = rect.get_x();
+                y = rect.get_y();
+            }
+        }
+    }
+}
+
+void
+SPDesktopWidget::setWindowPosition (Geom::Point p)
+{
+    if (window)
+    {
+        window->move (gint(round(p[Geom::X])), gint(round(p[Geom::Y])));
+    }
+}
+
+void
+SPDesktopWidget::setWindowSize (gint w, gint h)
+{
+    if (window)
+    {
+        window->set_default_size (w, h);
+        window->resize (w, h);
+    }
+}
+
+/**
+ * \note transientizing does not work on windows; when you minimize a document
+ * and then open it back, only its transient emerges and you cannot access
+ * the document window. The document window must be restored by rightclicking
+ * the taskbar button and pressing "Restore"
+ */
+void
+SPDesktopWidget::setWindowTransient (void *p, int transient_policy)
+{
+    if (window)
+    {
+        GtkWindow *w = GTK_WINDOW(window->gobj());
+        gtk_window_set_transient_for (GTK_WINDOW(p), w);
+
+        /*
+         * This enables "aggressive" transientization,
+         * i.e. dialogs always emerging on top when you switch documents. Note
+         * however that this breaks "click to raise" policy of a window
+         * manager because the switched-to document will be raised at once
+         * (so that its transients also could raise)
+         */
+        if (transient_policy == PREFS_DIALOGS_WINDOWS_AGGRESSIVE)
+            // without this, a transient window not always emerges on top
+            gtk_window_present (w);
+    }
+}
+
+void
+SPDesktopWidget::presentWindow()
+{
+    if (window)
+        window->present();
+}
+
+bool SPDesktopWidget::showInfoDialog( Glib::ustring const &message )
+{
+    bool result = false;
+    if (window)
+    {
+        Gtk::MessageDialog dialog(*window, message, false, Gtk::MESSAGE_INFO, Gtk::BUTTONS_OK);
+        dialog.property_destroy_with_parent() = true;
+        dialog.set_name("InfoDialog");
+        dialog.set_title(_("Note:")); // probably want to take this as a parameter.
+        dialog.run();
+    }
+    return result;
+}
+
+bool SPDesktopWidget::warnDialog (Glib::ustring const &text)
+{
+    Gtk::MessageDialog dialog (*window, text, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK_CANCEL);
+    gint response = dialog.run();
+    if (response == Gtk::RESPONSE_OK)
+        return true;
+    else
+        return false;
+}
+
+void
+SPDesktopWidget::iconify()
+{
+    GtkWindow *topw = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(_canvas->gobj())));
+    if (GTK_IS_WINDOW(topw)) {
+        if (desktop->is_iconified()) {
+            gtk_window_deiconify(topw);
+        } else {
+            gtk_window_iconify(topw);
+        }
+    }
+}
+
+void
+SPDesktopWidget::maximize()
+{
+    GtkWindow *topw = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(_canvas->gobj())));
+    if (GTK_IS_WINDOW(topw)) {
+        if (desktop->is_maximized()) {
+            gtk_window_unmaximize(topw);
+        } else {
+            gtk_window_maximize(topw);
+        }
+    }
+}
+
+void
+SPDesktopWidget::fullscreen()
+{
+    GtkWindow *topw = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(_canvas->gobj())));
+    if (GTK_IS_WINDOW(topw)) {
+        if (desktop->is_fullscreen()) {
+            gtk_window_unfullscreen(topw);
+            // widget layout is triggered by the resulting window_state_event
+        } else {
+            gtk_window_fullscreen(topw);
+            // widget layout is triggered by the resulting window_state_event
+        }
+    }
+}
+
+/**
+ * Hide whatever the user does not want to see in the window.
+ * Also move command toolbar to top or side as required.
+ */
+void SPDesktopWidget::layoutWidgets()
+{
+    SPDesktopWidget *dtw = this;
+    Glib::ustring pref_root;
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    if (desktop && desktop->is_focusMode()) {
+        pref_root = "/focus/";
+    } else if (desktop && desktop->is_fullscreen()) {
+        pref_root = "/fullscreen/";
+    } else {
+        pref_root = "/window/";
+    }
+
+    if (!prefs->getBool(pref_root + "commands/state", true)) {
+        gtk_widget_hide (dtw->commands_toolbox);
+    } else {
+        gtk_widget_show_all (dtw->commands_toolbox);
+    }
+
+    if (!prefs->getBool(pref_root + "snaptoolbox/state", true)) {
+        gtk_widget_hide (dtw->snap_toolbox);
+    } else {
+        gtk_widget_show_all (dtw->snap_toolbox);
+    }
+
+    if (!prefs->getBool(pref_root + "toppanel/state", true)) {
+        gtk_widget_hide (dtw->aux_toolbox);
+    } else {
+        // we cannot just show_all because that will show all tools' panels;
+        // this is a function from toolbox.cpp that shows only the current tool's panel
+        ToolboxFactory::showAuxToolbox(dtw->aux_toolbox);
+    }
+
+    if (!prefs->getBool(pref_root + "toolbox/state", true)) {
+        gtk_widget_hide (dtw->tool_toolbox);
+    } else {
+        gtk_widget_show_all (dtw->tool_toolbox);
+    }
+
+    if (!prefs->getBool(pref_root + "statusbar/state", true)) {
+        dtw->_statusbar->hide();
+    } else {
+        dtw->_statusbar->show_all();
+    }
+
+    if (!prefs->getBool(pref_root + "panels/state", true)) {
+        dtw->_panels->hide();
+    } else {
+        dtw->_panels->show_all();
+    }
+
+    _canvas_grid->ShowScrollbars(prefs->getBool(pref_root + "scrollbars/state", true));
+    _canvas_grid->ShowRulers(    prefs->getBool(pref_root + "rulers/state",     true));
+
+    // Move command toolbar as required.
+
+    // If interface_mode unset, use screen aspect ratio. Needs to be synced with "canvas-interface-mode" action.
+    Gdk::Rectangle monitor_geometry = Inkscape::UI::get_monitor_geometry_primary();
+    double const width  = monitor_geometry.get_width();
+    double const height = monitor_geometry.get_height();
+    bool widescreen = (height > 0 && width/height > 1.65);
+    widescreen = prefs->getInt(pref_root + "task/taskset", widescreen ? 2 : 0) == 2; // legacy
+    widescreen = prefs->getBool(pref_root + "interface_mode", widescreen);
+
+    auto commands_toolbox_cpp = dynamic_cast<Gtk::Bin *>(Glib::wrap(commands_toolbox));
+    if (commands_toolbox_cpp) {
+
+        // Unlink command toolbar.
+        commands_toolbox_cpp->reference(); // So toolbox is not deleted.
+        auto parent = commands_toolbox_cpp->get_parent();
+        parent->remove(*commands_toolbox_cpp);
+
+        auto orientation = Gtk::ORIENTATION_HORIZONTAL;
+        auto orientation_c = GTK_ORIENTATION_HORIZONTAL;
+        // Link command toolbar back.
+        if (!widescreen) {
+            _top_toolbars->attach(*commands_toolbox_cpp, 0, 0); // Always first
+            gtk_box_set_child_packing(_vbox->gobj(), commands_toolbox, false, true, 0, GTK_PACK_START); // expand, fill, padding, pack_type
+            orientation = Gtk::ORIENTATION_HORIZONTAL;
+            orientation_c = GTK_ORIENTATION_HORIZONTAL;
+            commands_toolbox_cpp->set_hexpand(true);
+        } else {
+            _hbox->add(*commands_toolbox_cpp);
+            gtk_box_set_child_packing(_hbox->gobj(), commands_toolbox, false, true, 0, GTK_PACK_START); // expand, fill, padding, pack_type
+            orientation = Gtk::ORIENTATION_VERTICAL;
+            orientation_c = GTK_ORIENTATION_VERTICAL;
+            commands_toolbox_cpp->set_hexpand(false);
+        }
+        commands_toolbox_cpp->unreference();
+
+        auto box = dynamic_cast<Gtk::Box *>(commands_toolbox_cpp->get_child());
+        if (box) {
+            box->set_orientation(orientation);
+            for (auto child : box->get_children()) {
+                if (auto toolbar = dynamic_cast<Gtk::Toolbar *>(child)) {
+                    gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar->gobj()), orientation_c);
+                    //toolbar->set_orientation(orientation); // Missing in C++ interface!
+                }
+            }
+        }
+    } else {
+        std::cerr << "SPDesktopWidget::layoutWidgets(): Wrong widget type for command toolbar!" << std::endl;
+    }
+
+    // Temporary for Gtk3: Gtk toolbar resets icon sizes, so reapply them.
+    // TODO: remove this call in Gtk4 after Gtk::Toolbar is eliminated.
+    apply_ctrlbar_settings();
+    repack_snaptoolbar();
+
+    Inkscape::UI::resize_widget_children(_top_toolbars);
+}
+
+Gtk::Toolbar *
+SPDesktopWidget::get_toolbar_by_name(const Glib::ustring& name)
+{
+    // The name is actually attached to the GtkGrid that contains
+    // the toolbar, so we need to get the grid first
+    auto widget = sp_search_by_name_recursive(Glib::wrap(aux_toolbox), name);
+    auto grid = dynamic_cast<Gtk::Grid*>(widget);
+
+    if (!grid) return nullptr;
+
+    auto child = grid->get_child_at(0,0);
+    auto tb = dynamic_cast<Gtk::Toolbar*>(child);
+
+    return tb;
+}
+
+void
+SPDesktopWidget::setToolboxFocusTo (const gchar* label)
+{
+    // First try looking for a named widget
+    auto hb = sp_search_by_name_recursive(Glib::wrap(aux_toolbox), label);
+
+    // Fallback to looking for a named data member (deprecated)
+    if (!hb) {
+        hb = Glib::wrap(GTK_WIDGET(sp_search_by_data_recursive(aux_toolbox, (gpointer) label)));
+    }
+
+    if (hb)
+    {
+        hb->grab_focus();
+    }
+}
+
+void
+SPDesktopWidget::setToolboxAdjustmentValue (gchar const *id, double value)
+{
+    // First try looking for a named widget
+    auto hb = sp_search_by_name_recursive(Glib::wrap(aux_toolbox), id);
+
+    // Fallback to looking for a named data member (deprecated)
+    if (!hb) {
+        hb = Glib::wrap(GTK_WIDGET(sp_search_by_data_recursive(aux_toolbox, (gpointer)id)));
+    }
+
+    if (hb) {
+        auto sb = dynamic_cast<Inkscape::UI::Widget::SpinButtonToolItem *>(hb);
+        auto a = sb->get_adjustment();
+
+        if(a) a->set_value(value);
+    }
+
+    else g_warning ("Could not find GtkAdjustment for %s\n", id);
+}
+
+
+bool
+SPDesktopWidget::isToolboxButtonActive (const gchar* id)
+{
+    bool isActive = false;
+    auto thing = sp_search_by_name_recursive(Glib::wrap(aux_toolbox), id);
+
+    // The toolbutton could be a few different types so try casting to
+    // each of them.
+    // TODO: This will be simpler in Gtk+ 4 when ToolItems have gone
+    auto toggle_button      = dynamic_cast<Gtk::ToggleButton *>(thing);
+    auto toggle_tool_button = dynamic_cast<Gtk::ToggleToolButton *>(thing);
+
+    if ( !thing ) {
+        //g_message( "Unable to locate item for {%s}", id );
+    } else if (toggle_button) {
+        isActive = toggle_button->get_active();
+    } else if (toggle_tool_button) {
+        isActive = toggle_tool_button->get_active();
+    } else {
+        //g_message( "Item for {%s} is of an unsupported type", id );
+    }
+
+    return isActive;
+}
+
+SPDesktopWidget::SPDesktopWidget(InkscapeWindow *inkscape_window, SPDocument *document)
+    : SPDesktopWidget(inkscape_window)
+{
+    set_name("SPDesktopWidget");
+
+    SPDesktopWidget *dtw = this;
+
+    SPNamedView *namedview = document->getNamedView();
+
+    dtw->_dt2r = 1. / namedview->display_units->factor;
+
+    // This section seems backwards!
+    dtw->desktop = new SPDesktop();
+    dtw->desktop->init (namedview, dtw->_canvas, this);
+    dtw->_canvas->set_desktop(desktop);
+    INKSCAPE.add_desktop (dtw->desktop);
+
+    // Add the shape geometry to libavoid for autorouting connectors.
+    // This needs desktop set for its spacing preferences.
+    init_avoided_shape_geometry(dtw->desktop);
+
+    dtw->_selected_style->setDesktop(dtw->desktop);
+
+    /* Once desktop is set, we can update rulers */
+    dtw->_canvas_grid->UpdateRulers();
+
+    dtw->setView(dtw->desktop);
+
+    /* Listen on namedview modification */
+    dtw->modified_connection = namedview->connectModified(sigc::mem_fun(*dtw, &SPDesktopWidget::namedviewModified));
+
+    _layer_selector->setDesktop(dtw->desktop);
+
+    // We never want a page widget if there's no desktop.
+    _page_selector = Gtk::manage(new Inkscape::UI::Widget::PageSelector(desktop));
+    _statusbar->pack_end(*_page_selector, false, false);
+
+    ToolboxFactory::setToolboxDesktop(dtw->aux_toolbox, dtw->desktop);
+
+    dtw->layoutWidgets();
+
+    dtw->_panels->setDesktop(dtw->desktop);
+}
+
+/**
+ * Choose where to pack the snap toolbar.
+ */
+void SPDesktopWidget::repack_snaptoolbar()
+{
+    Inkscape::Preferences* prefs = Inkscape::Preferences::get();
+    bool is_perm = prefs->getInt("/toolbox/simplesnap", 1) == 2;
+    auto& aux = *Glib::wrap(aux_toolbox);
+    auto& snap = *Glib::wrap(snap_toolbox);
+
+    // Only remove from the parent if the status has changed
+    auto parent = snap.get_parent();
+    if (parent && ((is_perm && parent != _hbox) || (!is_perm && parent != _top_toolbars))) {
+        parent->remove(snap);
+    }
+
+    // Only repack if there's no parent widget now.
+    if (!snap.get_parent()) {
+        if (is_perm) {
+            ToolboxFactory::setOrientation(snap_toolbox, GTK_ORIENTATION_VERTICAL);
+            _hbox->pack_end(snap, false, true);
+        } else {
+            ToolboxFactory::setOrientation(snap_toolbox, GTK_ORIENTATION_HORIZONTAL);
+            _top_toolbars->attach(snap, 1, 0, 1, 2);
+        }
+    }
+
+    // Always reset the various constraints, even if not repacked.
+    if (is_perm) {
+        snap.set_valign(Gtk::ALIGN_START);
+    } else {
+        // This ensures that the Snap toolbox is on the top and only takes the needed space.
+        if (_top_toolbars->get_children().size() == 3 && gtk_widget_get_visible(commands_toolbox)) {
+            _top_toolbars->child_property_width(aux) = 2;
+            _top_toolbars->child_property_height(snap) =  1;
+            snap.set_valign(Gtk::ALIGN_START);
+        }
+        else {
+            _top_toolbars->child_property_width(aux) = 1;
+            _top_toolbars->child_property_height(snap) =  2;
+            snap.set_valign(Gtk::ALIGN_CENTER);
+        }
+    }
+}
+
+void
+SPDesktopWidget::update_rulers()
+{
+    _canvas_grid->UpdateRulers();
+}
+
+
+void SPDesktopWidget::namedviewModified(SPObject *obj, guint flags)
+{
+    auto nv = cast<SPNamedView>(obj);
+
+    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+        _dt2r = 1. / nv->display_units->factor;
+
+        _canvas_grid->GetVRuler()->set_unit(nv->getDisplayUnit());
+        _canvas_grid->GetHRuler()->set_unit(nv->getDisplayUnit());
+        _canvas_grid->GetVRuler()->set_tooltip_text(gettext(nv->display_units->name_plural.c_str()));
+        _canvas_grid->GetHRuler()->set_tooltip_text(gettext(nv->display_units->name_plural.c_str()));
+        _canvas_grid->UpdateRulers();
+
+        /* This loops through all the grandchildren of aux toolbox,
+         * and for each that it finds, it performs an sp_search_by_name_recursive(),
+         * looking for widgets named "unit-tracker" (this is used by
+         * all toolboxes to refer to the unit selector). The default document units
+         * is then selected within these unit selectors.
+         *
+         * This should solve: https://bugs.launchpad.net/inkscape/+bug/362995
+         */
+        if (GTK_IS_CONTAINER(aux_toolbox)) {
+            std::vector<Gtk::Widget*> ch = Glib::wrap(GTK_CONTAINER(aux_toolbox))->get_children();
+            for (auto i:ch) {
+                if (auto container = dynamic_cast<Gtk::Container *>(i)) {
+                    std::vector<Gtk::Widget*> grch = container->get_children();
+                    for (auto j:grch) {
+
+                        if (!GTK_IS_WIDGET(j->gobj())) // wasn't a widget
+                            continue;
+
+                        // Don't apply to text toolbar. We want to be able to
+                        // use different units for text. (Bug 1562217)
+                        const Glib::ustring name = j->get_name();
+                        if ( name == "TextToolbar" || name == "MeasureToolbar" || name == "CalligraphicToolbar" )
+                            continue;
+
+                        auto tracker = dynamic_cast<Inkscape::UI::Widget::ComboToolItem*>(sp_search_by_name_recursive(j, "unit-tracker"));
+
+                        if (tracker) { // it's null when inkscape is first opened
+                            if (auto ptr = static_cast<UnitTracker*>(tracker->get_data(Glib::Quark("unit-tracker")))) {
+                                ptr->setActiveUnit(nv->display_units);
+                            }
+                        }
+                    } // grandchildren
+                } // if child is a container
+            } // children
+        } // if aux_toolbox is a container
+    }
+}
+
+void
+SPDesktopWidget::on_adjustment_value_changed()
+{
+    if (update)
+        return;
+
+    update = true;
+
+    // Do not call canvas->scrollTo directly... messes up 'offset'.
+    desktop->scroll_absolute(Geom::Point(_canvas_grid->GetHAdj()->get_value(),
+                                         _canvas_grid->GetVAdj()->get_value()));
+
+    update = false;
+}
+
+/* we make the desktop window with focus active, signal is connected in interface.c */
+bool SPDesktopWidget::onFocusInEvent(GdkEventFocus*)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    if (prefs->getBool("/options/bitmapautoreload/value", true)) {
+        std::vector<SPObject *> imageList = (desktop->doc())->getResourceList("image");
+        for (auto it : imageList) {
+            auto image = cast<SPImage>(it);
+            image->refresh_if_outdated();
+        }
+    }
+
+    INKSCAPE.activate_desktop (desktop);
+
+    return false;
+}
+
+// ------------------------ Zoom ------------------------
+static gdouble
+sp_dtw_zoom_value_to_display (gdouble value)
+{
+    return floor (10 * (pow (2, value) * 100.0 + 0.05)) / 10;
+}
+
+static gdouble
+sp_dtw_zoom_display_to_value (gdouble value)
+{
+    return  log (value / 100.0) / log (2);
+}
+
+int
+SPDesktopWidget::zoom_input(double *new_val)
+{
+    double new_typed = g_strtod (_zoom_status->get_text().c_str(), nullptr);
+    *new_val = sp_dtw_zoom_display_to_value (new_typed);
+    return true;
+}
+
+bool
+SPDesktopWidget::zoom_output()
+{
+    gchar b[64];
+    double val = sp_dtw_zoom_value_to_display (_zoom_status->get_value());
+    if (val < 10) {
+        g_snprintf (b, 64, "%4.1f%%", val);
+    } else {
+        g_snprintf (b, 64, "%4.0f%%", val);
+    }
+    _zoom_status->set_text(b);
+    return true;
+}
+
+void
+SPDesktopWidget::zoom_value_changed()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    double const zoom_factor = pow (2, _zoom_status->get_value());
+
+    // Zoom around center of window
+    Geom::Rect const d_canvas = _canvas->get_area_world();
+    Geom::Point midpoint = desktop->w2d(d_canvas.midpoint());
+
+    _zoom_status_value_changed_connection.block();
+    if(prefs->getDouble("/options/zoomcorrection/shown", true)) {
+        desktop->zoom_realworld(midpoint, zoom_factor);
+    } else {
+        desktop->zoom_absolute(midpoint, zoom_factor);
+    }
+    _zoom_status_value_changed_connection.unblock();
+    _zoom_status->defocus();
+}
+
+void
+SPDesktopWidget::zoom_menu_handler(double factor)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    if(prefs->getDouble("/options/zoomcorrection/shown", true)) {
+        desktop->zoom_realworld(desktop->current_center(), factor);
+    } else {
+        desktop->zoom_absolute(desktop->current_center(), factor, false);
+    }
+}
+
+
+
+void
+SPDesktopWidget::zoom_populate_popup(Gtk::Menu *menu)
+{
+    for ( auto iter : menu->get_children()) {
+        menu->remove(*iter);
+    }
+
+    auto item_1000 = Gtk::manage(new Gtk::MenuItem("1000%"));
+    auto item_500  = Gtk::manage(new Gtk::MenuItem("500%"));
+    auto item_200  = Gtk::manage(new Gtk::MenuItem("200%"));
+    auto item_100  = Gtk::manage(new Gtk::MenuItem("100%"));
+    auto item_50   = Gtk::manage(new Gtk::MenuItem( "50%"));
+    auto item_25   = Gtk::manage(new Gtk::MenuItem( "25%"));
+    auto item_10   = Gtk::manage(new Gtk::MenuItem( "10%"));
+
+    item_1000->signal_activate().connect(sigc::bind(sigc::mem_fun(*this, &SPDesktopWidget::zoom_menu_handler), 10.00));
+    item_500->signal_activate().connect( sigc::bind(sigc::mem_fun(*this, &SPDesktopWidget::zoom_menu_handler),  5.00));
+    item_200->signal_activate().connect( sigc::bind(sigc::mem_fun(*this, &SPDesktopWidget::zoom_menu_handler),  2.00));
+    item_100->signal_activate().connect( sigc::bind(sigc::mem_fun(*this, &SPDesktopWidget::zoom_menu_handler),  1.00));
+    item_50->signal_activate().connect(  sigc::bind(sigc::mem_fun(*this, &SPDesktopWidget::zoom_menu_handler),  0.50));
+    item_25->signal_activate().connect(  sigc::bind(sigc::mem_fun(*this, &SPDesktopWidget::zoom_menu_handler),  0.25));
+    item_10->signal_activate().connect(  sigc::bind(sigc::mem_fun(*this, &SPDesktopWidget::zoom_menu_handler),  0.10));
+
+    menu->append(*item_1000);
+    menu->append(*item_500);
+    menu->append(*item_200);
+    menu->append(*item_100);
+    menu->append(*item_50);
+    menu->append(*item_25);
+    menu->append(*item_10);
+
+    auto sep = Gtk::manage(new Gtk::SeparatorMenuItem());
+    menu->append(*sep);
+
+    auto item_page = Gtk::manage(new Gtk::MenuItem(_("Page")));
+    item_page->signal_activate().connect([=]() { desktop->getDocument()->getPageManager().zoomToSelectedPage(desktop); });
+    menu->append(*item_page);
+
+    auto item_drawing = Gtk::manage(new Gtk::MenuItem(_("Drawing")));
+    item_drawing->signal_activate().connect(sigc::mem_fun(*desktop, &SPDesktop::zoom_drawing));
+    menu->append(*item_drawing);
+
+    auto item_selection = Gtk::manage(new Gtk::MenuItem(_("Selection")));
+    item_selection->signal_activate().connect(sigc::mem_fun(*desktop, &SPDesktop::zoom_selection));
+    menu->append(*item_selection);
+
+    auto item_center_page = Gtk::manage(new Gtk::MenuItem(_("Centre Page")));
+    item_center_page->signal_activate().connect([=]() { desktop->getDocument()->getPageManager().centerToSelectedPage(desktop); });
+    menu->append(*item_center_page);
+
+    menu->show_all();
+}
+
+
+void
+SPDesktopWidget::sticky_zoom_toggled()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setBool("/options/stickyzoom/value", _canvas_grid->GetStickyZoom()->get_active());
+}
+
+void
+SPDesktopWidget::sticky_zoom_updated()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    _canvas_grid->GetStickyZoom()->set_active(prefs->getBool("/options/stickyzoom/value", false));
+}
+
+void
+SPDesktopWidget::update_zoom()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    // It's very important that the value used in set_value is the same as the one
+    // set as it otherwise creates an infinate loop between the spin button and update_zoom
+    double correction = 1.0;
+    if(prefs->getDouble("/options/zoomcorrection/shown", true)) {
+        correction = prefs->getDouble("/options/zoomcorrection/value", 1.0);
+    }
+    _zoom_status_value_changed_connection.block();
+    _zoom_status->set_value(log(desktop->current_zoom() / correction) / log(2));
+    _zoom_status->queue_draw();
+    _zoom_status_value_changed_connection.unblock();
+}
+
+
+// ---------------------- Rotation ------------------------
+
+bool
+SPDesktopWidget::rotation_output()
+{
+    gchar b[64];
+    double val = _rotation_status->get_value();
+
+    if (val < -180) val += 360;
+    if (val >  180) val -= 360;
+
+    g_snprintf (b, 64, "%7.2f°", val);
+
+    _rotation_status->set_text(b);
+    return true;
+}
+
+void
+SPDesktopWidget::rotation_value_changed()
+{
+    double const rotate_factor = M_PI / 180.0 * _rotation_status->get_value();
+    // std::cout << "SPDesktopWidget::rotation_value_changed: "
+    //           << _rotation_status->get_value()
+    //           << "  (" << rotate_factor << ")" <<std::endl;
+
+    // Rotate around center of window
+    Geom::Rect const d_canvas = _canvas->get_area_world();
+    _rotation_status_value_changed_connection.block();
+    Geom::Point midpoint = desktop->w2d(d_canvas.midpoint());
+    desktop->rotate_absolute_center_point (midpoint, rotate_factor);
+    _rotation_status_value_changed_connection.unblock();
+
+    _rotation_status->defocus();
+}
+
+void
+SPDesktopWidget::rotation_populate_popup(Gtk::Menu *menu)
+{
+    for ( auto iter : menu->get_children()) {
+        menu->remove(*iter);
+    }
+
+    auto item_m135 = Gtk::manage(new Gtk::MenuItem("-135°"));
+    auto item_m90  = Gtk::manage(new Gtk::MenuItem( "-90°"));
+    auto item_m45  = Gtk::manage(new Gtk::MenuItem( "-45°"));
+    auto item_0    = Gtk::manage(new Gtk::MenuItem(   "0°"));
+    auto item_p45  = Gtk::manage(new Gtk::MenuItem(  "45°"));
+    auto item_p90  = Gtk::manage(new Gtk::MenuItem(  "90°"));
+    auto item_p135 = Gtk::manage(new Gtk::MenuItem( "135°"));
+    auto item_p180 = Gtk::manage(new Gtk::MenuItem( "180°"));
+
+    item_m135->signal_activate().connect(sigc::bind(sigc::mem_fun(*_rotation_status, &Gtk::SpinButton::set_value), -135));
+    item_m90->signal_activate().connect( sigc::bind(sigc::mem_fun(*_rotation_status, &Gtk::SpinButton::set_value), -90));
+    item_m45->signal_activate().connect( sigc::bind(sigc::mem_fun(*_rotation_status, &Gtk::SpinButton::set_value), -45));
+    item_0->signal_activate().connect(   sigc::bind(sigc::mem_fun(*_rotation_status, &Gtk::SpinButton::set_value),   0));
+    item_p45->signal_activate().connect( sigc::bind(sigc::mem_fun(*_rotation_status, &Gtk::SpinButton::set_value),  45));
+    item_p90->signal_activate().connect( sigc::bind(sigc::mem_fun(*_rotation_status, &Gtk::SpinButton::set_value),  90));
+    item_p135->signal_activate().connect(sigc::bind(sigc::mem_fun(*_rotation_status, &Gtk::SpinButton::set_value), 135));
+    item_p180->signal_activate().connect(sigc::bind(sigc::mem_fun(*_rotation_status, &Gtk::SpinButton::set_value), 180));
+
+    menu->append(*item_m135);
+    menu->append(*item_m90);
+    menu->append(*item_m45);
+    menu->append(*item_0);
+    menu->append(*item_p45);
+    menu->append(*item_p90);
+    menu->append(*item_p135);
+    menu->append(*item_p180);
+
+    menu->show_all();
+}
+
+
+void
+SPDesktopWidget::update_rotation()
+{
+    _rotation_status_value_changed_connection.block();
+    _rotation_status->set_value(desktop->current_rotation() / M_PI * 180.0);
+    _rotation_status->queue_draw();
+    _rotation_status_value_changed_connection.unblock();
+
+}
+
+
+// --------------- Rulers/Scrollbars/Etc. -----------------
+void
+SPDesktopWidget::toggle_command_palette() {
+    // TODO: Turn into action and remove this function.
+    _canvas_grid->ToggleCommandPalette();
+}
+
+void
+SPDesktopWidget::toggle_rulers()
+{
+    // TODO: Turn into action and remove this function.
+    _canvas_grid->ToggleRulers();
+}
+
+void
+SPDesktopWidget::toggle_scrollbars()
+{
+    // TODO: Turn into action and remove this function.
+    _canvas_grid->ToggleScrollbars();
+}
+
+bool
+SPDesktopWidget::get_color_prof_adj_enabled() const
+{
+    auto _cms_adjust = _canvas_grid->GetCmsAdjust();
+    return _cms_adjust->get_sensitive() && _cms_adjust->get_active();
+}
+
+void
+SPDesktopWidget::toggle_color_prof_adj()
+{
+    auto _cms_adjust = _canvas_grid->GetCmsAdjust();
+    if (_cms_adjust->get_sensitive()) {
+        bool active = _cms_adjust->get_active();
+        _cms_adjust->set_active(!active);
+    }
+}
+
+static void
+set_adjustment (Gtk::Adjustment *adj, double l, double u, double ps, double si, double pi)
+{
+    if ((l != adj->get_lower()) ||
+        (u != adj->get_upper()) ||
+        (ps != adj->get_page_size()) ||
+        (si != adj->get_step_increment()) ||
+        (pi != adj->get_page_increment())) {
+	    adj->set_lower(l);
+	    adj->set_upper(u);
+	    adj->set_page_size(ps);
+	    adj->set_step_increment(si);
+	    adj->set_page_increment(pi);
+    }
+}
+
+void
+SPDesktopWidget::update_scrollbars(double scale)
+{
+    if (update) return;
+    update = true;
+
+    /* The desktop region we always show unconditionally */
+    SPDocument *doc = desktop->doc();
+
+    auto deskarea = doc->preferredBounds();
+    deskarea->expandBy(doc->getDimensions()); // Double size
+
+    /* The total size of pages should be added unconditionally */
+    deskarea->unionWith(doc->getPageManager().getDesktopRect());
+
+    if (Inkscape::Preferences::get()->getInt("/tools/bounding_box") == 0) {
+        deskarea->unionWith(doc->getRoot()->desktopVisualBounds());
+    } else {
+        deskarea->unionWith(doc->getRoot()->desktopGeometricBounds());
+    }
+
+    /* Canvas region we always show unconditionally */
+    double const y_dir = desktop->yaxisdir();
+    Geom::Rect carea( Geom::Point(deskarea->left()  * scale - 64, (deskarea->top()    * scale + 64) * y_dir),
+                      Geom::Point(deskarea->right() * scale + 64, (deskarea->bottom() * scale - 64) * y_dir) );
+
+    Geom::Rect viewbox = _canvas->get_area_world();
+
+    /* Viewbox is always included into scrollable region */
+    carea = Geom::unify(carea, viewbox);
+
+    auto _hadj = _canvas_grid->GetHAdj();
+    auto _vadj = _canvas_grid->GetVAdj();
+    set_adjustment(_hadj, carea.min()[Geom::X], carea.max()[Geom::X],
+                   viewbox.dimensions()[Geom::X],
+                   0.1 * viewbox.dimensions()[Geom::X],
+                   viewbox.dimensions()[Geom::X]);
+    _hadj->set_value(viewbox.min()[Geom::X]);
+
+    set_adjustment(_vadj, carea.min()[Geom::Y], carea.max()[Geom::Y],
+                   viewbox.dimensions()[Geom::Y],
+                   0.1 * viewbox.dimensions()[Geom::Y],
+                   viewbox.dimensions()[Geom::Y]);
+    _vadj->set_value(viewbox.min()[Geom::Y]);
+
+    update = false;
+}
+
+gint
+SPDesktopWidget::ruler_event(GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw, bool horiz)
+{
+    switch (event->type) {
+    case GDK_BUTTON_PRESS:
+        dtw->on_ruler_box_button_press_event(&event->button, Glib::wrap(widget), horiz);
+        break;
+    case GDK_MOTION_NOTIFY:
+        dtw->on_ruler_box_motion_notify_event(&event->motion, Glib::wrap(widget), horiz);
+        break;
+    case GDK_BUTTON_RELEASE:
+        dtw->on_ruler_box_button_release_event(&event->button, Glib::wrap(widget), horiz);
+        break;
+    default:
+            break;
+    }
+
+    return FALSE;
+}
+
+bool
+SPDesktopWidget::on_ruler_box_motion_notify_event(GdkEventMotion *event, Gtk::Widget *widget, bool horiz)
+{
+    auto origin = horiz ? Inkscape::UI::Tools::DelayedSnapEvent::GUIDE_HRULER
+                        : Inkscape::UI::Tools::DelayedSnapEvent::GUIDE_VRULER;
+    desktop->event_context->snap_delay_handler(widget->gobj(), this, event, origin);
+
+    int wx, wy;
+
+    GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(_canvas->gobj()));
+
+    gint width, height;
+
+    gdk_window_get_device_position(window, event->device, &wx, &wy, nullptr);
+    gdk_window_get_geometry(window, nullptr /*x*/, nullptr /*y*/, &width, &height);
+
+    Geom::Point const event_win(wx, wy);
+
+    if (_ruler_clicked) {
+        Geom::Point event_w(_canvas->canvas_to_world(event_win));
+        Geom::Point event_dt(desktop->w2d(event_w));
+
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        gint tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
+        if ( ( abs( (gint) event->x - _xp ) < tolerance )
+                && ( abs( (gint) event->y - _yp ) < tolerance ) ) {
+            return false;
+        }
+
+        _ruler_dragged = true;
+
+        // explicitly show guidelines; if I draw a guide, I want them on
+        if ((horiz ? wy : wx) >= 0) {
+            desktop->namedview->setShowGuides(true);
+        }
+
+        Geom::Point normal = _normal;
+        if (!(event->state & GDK_SHIFT_MASK)) {
+            ruler_snap_new_guide(desktop, event_dt, normal);
+        }
+        _active_guide->set_normal(normal);
+        _active_guide->set_origin(event_dt);
+
+        desktop->set_coordinate_status(event_dt);
+    }
+
+    return false;
+}
+
+// End guide creation or toggle guides on/off.
+bool
+SPDesktopWidget::on_ruler_box_button_release_event(GdkEventButton *event, Gtk::Widget *widget, bool horiz)
+{
+    int wx, wy;
+
+    GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(_canvas->gobj()));
+
+    gint width, height;
+
+    gdk_window_get_device_position(window, event->device, &wx, &wy, nullptr);
+    gdk_window_get_geometry(window, nullptr /*x*/, nullptr /*y*/, &width, &height);
+
+    Geom::Point const event_win(wx, wy);
+
+    if (_ruler_clicked && event->button == 1) {
+        desktop->event_context->discard_delayed_snap_event();
+
+        auto seat = gdk_device_get_seat(event->device);
+        gdk_seat_ungrab(seat);
+
+        Geom::Point const event_w(_canvas->canvas_to_world(event_win));
+        Geom::Point event_dt(desktop->w2d(event_w));
+
+        Geom::Point normal = _normal;
+        if (!(event->state & GDK_SHIFT_MASK)) {
+            ruler_snap_new_guide(desktop, event_dt, normal);
+        }
+
+        _active_guide.reset();
+        if ((horiz ? wy : wx) >= 0) {
+            Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
+            Inkscape::XML::Node *repr = xml_doc->createElement("sodipodi:guide");
+
+            // If root viewBox set, interpret guides in terms of viewBox (90/96)
+            double newx = event_dt.x();
+            double newy = event_dt.y();
+
+            // <sodipodi:guide> stores inverted y-axis coordinates
+            if (desktop->is_yaxisdown()) {
+                newy = desktop->doc()->getHeight().value("px") - newy;
+                normal[Geom::Y] *= -1.0;
+            }
+
+            SPRoot *root = desktop->doc()->getRoot();
+            if( root->viewBox_set ) {
+                newx = newx * root->viewBox.width()  / root->width.computed;
+                newy = newy * root->viewBox.height() / root->height.computed;
+            }
+            repr->setAttributePoint("position", Geom::Point( newx, newy ));
+            repr->setAttributePoint("orientation", normal);
+            desktop->namedview->appendChild(repr);
+            Inkscape::GC::release(repr);
+            DocumentUndo::done(desktop->getDocument(), _("Create guide"), "");
+        }
+        desktop->set_coordinate_status(event_dt);
+
+        if (!_ruler_dragged) {
+            // Ruler click (without drag) toggle the guide visibility on and off
+            desktop->namedview->toggleShowGuides();
+        }
+
+        _ruler_clicked = false;
+        _ruler_dragged = false;
+    }
+
+    return false;
+}
+
+// Start guide creation by dragging from ruler.
+bool
+SPDesktopWidget::on_ruler_box_button_press_event(GdkEventButton *event, Gtk::Widget *widget, bool horiz)
+{
+    if (_ruler_clicked) // event triggered on a double click: do no process the click
+        return false;
+
+    int wx, wy;
+
+    GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(_canvas->gobj()));
+
+    gint width, height;
+
+    gdk_window_get_device_position(window, event->device, &wx, &wy, nullptr);
+    gdk_window_get_geometry(window, nullptr /*x*/, nullptr /*y*/, &width, &height);
+
+    Geom::Point const event_win(wx, wy);
+
+    if (event->button == 1) {
+        _ruler_clicked = true;
+        _ruler_dragged = false;
+        // save click origin
+        _xp = (gint) event->x;
+        _yp = (gint) event->y;
+
+        Geom::Point const event_w(_canvas->canvas_to_world(event_win));
+        Geom::Point const event_dt(desktop->w2d(event_w));
+
+        // calculate the normal of the guidelines when dragged from the edges of rulers.
+        auto const y_dir = desktop->yaxisdir();
+        Geom::Point normal_bl_to_tr(1., y_dir); //bottomleft to topright
+        Geom::Point normal_tr_to_bl(-1., y_dir); //topright to bottomleft
+        normal_bl_to_tr.normalize();
+        normal_tr_to_bl.normalize();
+        SPGrid * grid = desktop->namedview->getFirstEnabledGrid();
+        if (grid) {
+            if (grid->getType() == GridType::AXONOMETRIC ) {
+                auto angle_x = Geom::rad_from_deg(grid->getAngleX());
+                auto angle_z = Geom::rad_from_deg(grid->getAngleZ());
+                if (event->state & GDK_CONTROL_MASK) {
+                    // guidelines normal to gridlines
+                    normal_bl_to_tr = Geom::Point::polar(-angle_x, 1.0);
+                    normal_tr_to_bl = Geom::Point::polar(angle_z, 1.0);
+                } else {
+                    normal_bl_to_tr = Geom::rot90(Geom::Point::polar(angle_z, 1.0));
+                    normal_tr_to_bl = Geom::rot90(Geom::Point::polar(-angle_x, 1.0));
+                }
+            }
+        }
+        if (horiz) {
+            if (wx < 50) {
+                _normal = normal_bl_to_tr;
+            } else if (wx > width - 50) {
+                _normal = normal_tr_to_bl;
+            } else {
+                _normal = Geom::Point(0.,1.);
+            }
+        } else {
+            if (wy < 50) {
+                _normal = normal_bl_to_tr;
+            } else if (wy > height - 50) {
+                _normal = normal_tr_to_bl;
+            } else {
+                _normal = Geom::Point(1.,0.);
+            }
+        }
+
+        _active_guide = make_canvasitem<Inkscape::CanvasItemGuideLine>(desktop->getCanvasGuides(), Glib::ustring(), event_dt, _normal);
+        _active_guide->set_stroke(desktop->namedview->guidehicolor);
+
+        // Ruler grabs all events until button release.
+        auto window = widget->get_window()->gobj();
+        auto seat = gdk_device_get_seat(event->device);
+        gdk_seat_grab(seat,
+                window,
+                GDK_SEAT_CAPABILITY_ALL_POINTING,
+                FALSE,
+                nullptr,
+                (GdkEvent*)event,
+                nullptr,
+                nullptr);
+    }
+
+    return false;
+}
+
+void
+SPDesktopWidget::ruler_snap_new_guide(SPDesktop *desktop, Geom::Point &event_dt, Geom::Point &normal)
+{
+    desktop->getCanvas()->grab_focus();
+    SnapManager &m = desktop->namedview->snap_manager;
+    m.setup(desktop);
+    // We're dragging a brand new guide, just pulled of the rulers seconds ago. When snapping to a
+    // path this guide will change it slope to become either tangential or perpendicular to that path. It's
+    // therefore not useful to try tangential or perpendicular snapping, so this will be disabled temporarily
+    bool pref_perp = m.snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_PATH_PERPENDICULAR);
+    bool pref_tang = m.snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_PATH_TANGENTIAL);
+    m.snapprefs.setTargetSnappable(Inkscape::SNAPTARGET_PATH_PERPENDICULAR, false);
+    m.snapprefs.setTargetSnappable(Inkscape::SNAPTARGET_PATH_TANGENTIAL, false);
+    // We only have a temporary guide which is not stored in our document yet.
+    // Because the guide snapper only looks in the document for guides to snap to,
+    // we don't have to worry about a guide snapping to itself here
+    Geom::Point normal_orig = normal;
+    m.guideFreeSnap(event_dt, normal, false, false);
+    // After snapping, both event_dt and normal have been modified accordingly; we'll take the normal (of the
+    // curve we snapped to) to set the normal the guide. And rotate it by 90 deg. if needed
+    if (pref_perp) { // Perpendicular snapping to paths is requested by the user, so let's do that
+        if (normal != normal_orig) {
+            normal = Geom::rot90(normal);
+        }
+    }
+    if (!(pref_tang || pref_perp)) { // if we don't want to snap either perpendicularly or tangentially, then
+        normal = normal_orig; // we must restore the normal to it's original state
+    }
+    // Restore the preferences
+    m.snapprefs.setTargetSnappable(Inkscape::SNAPTARGET_PATH_PERPENDICULAR, pref_perp);
+    m.snapprefs.setTargetSnappable(Inkscape::SNAPTARGET_PATH_TANGENTIAL, pref_tang);
+    m.unSetup();
+}
+
+Gio::ActionMap* SPDesktopWidget::get_action_map() {
+    return window;
+}
+
+/*
+  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/widgets/desktop-widget.h b/src/widgets/desktop-widget.h
new file mode 100644
index 0000000..70f4613
--- /dev/null
+++ b/src/widgets/desktop-widget.h
@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_SP_DESKTOP_WIDGET_H
+#define SEEN_SP_DESKTOP_WIDGET_H
+
+/** \file
+ * SPDesktopWidget: handling Gtk events on a desktop.
+ *
+ * Authors:
+ *      Jon A. Cruz <jon@joncruz.org> (c) 2010
+ *      John Bintz <jcoswell@coswellproductions.org> (c) 2006
+ *      Ralf Stephan <ralf@ark.in-berlin.de> (c) 2005
+ *      Abhishek Sharma
+ *      ? -2004
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"  // only include where actually required!
+#endif
+
+#include <cstddef>
+#include <2geom/point.h>
+#include <sigc++/connection.h>
+#include <gtkmm.h>
+
+#include "message.h"
+#include "preferences.h"
+#include "ui/view/view-widget.h"
+#include "display/control/canvas-item-ptr.h"
+
+// forward declaration
+typedef struct _EgeColorProfTracker EgeColorProfTracker;
+
+class InkscapeWindow;
+struct SPCanvasItem;
+class SPDocument;
+class SPDesktop;
+struct SPDesktopWidget;
+class SPObject;
+
+namespace Inkscape {
+  class CanvasItemGuideLine;
+namespace UI {
+namespace Dialog {
+class DialogContainer;
+class DialogMultipaned;
+class SwatchesPanel;
+} // namespace Dialog
+
+namespace Widget {
+  class Button;
+  class Canvas;
+  class CanvasGrid;
+  class LayerSelector;
+  class PageSelector;
+  class SelectedStyle;
+  class SpinButton;
+  class Ruler;
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+#define SP_DESKTOP_WIDGET(o) dynamic_cast<SPDesktopWidget*>(o)
+#define SP_IS_DESKTOP_WIDGET(o) bool(dynamic_cast<SPDesktopWidget const *>(o))
+
+void sp_desktop_widget_show_decorations(SPDesktopWidget *dtw, gboolean show);
+void sp_desktop_widget_update_hruler (SPDesktopWidget *dtw);
+void sp_desktop_widget_update_vruler (SPDesktopWidget *dtw);
+
+/* Show/hide rulers & scrollbars */
+void sp_desktop_widget_update_scrollbars (SPDesktopWidget *dtw, double scale);
+
+/// A GtkEventBox on an SPDesktop.
+class SPDesktopWidget : public SPViewWidget {
+    using parent_type = SPViewWidget;
+
+    SPDesktopWidget(InkscapeWindow *inkscape_window);
+
+public:
+    SPDesktopWidget(InkscapeWindow *inkscape_window, SPDocument *document);
+    ~SPDesktopWidget() override;
+
+    Inkscape::UI::Widget::CanvasGrid *get_canvas_grid() { return _canvas_grid; }  // Temp, I hope!
+    Inkscape::UI::Widget::Canvas     *get_canvas()      { return _canvas; }
+
+    Gio::ActionMap* get_action_map();
+
+    void on_realize() override;
+    void on_unrealize() override;
+
+    sigc::connection modified_connection;
+
+    SPDesktop *desktop = nullptr;
+
+    InkscapeWindow *window = nullptr;
+    Gtk::MenuBar *_menubar;
+private:
+    // Flags for ruler event handling
+    bool _ruler_clicked = false; ///< True if the ruler has been clicked
+    bool _ruler_dragged = false; ///< True if a drag on the ruler is occurring
+
+    bool update = false;
+
+    CanvasItemPtr<Inkscape::CanvasItemGuideLine> _active_guide; ///< The guide being handled during a ruler event
+    Geom::Point _normal; ///< Normal to the guide currently being handled during ruler event
+    int _xp = 0; ///< x coordinate for start of drag
+    int _yp = 0; ///< y coordinate for start of drag
+
+    // The root vbox of the window layout.
+    Gtk::Box *_vbox;
+
+    Gtk::Paned *_tbbox;
+    Gtk::Box *_hbox;
+    Inkscape::UI::Dialog::DialogContainer *_container = nullptr;
+    Inkscape::UI::Dialog::DialogMultipaned *_columns;
+    Gtk::Grid* _top_toolbars;
+
+    Gtk::Box     *_statusbar;
+
+    Inkscape::UI::Dialog::SwatchesPanel *_panels;
+
+    Glib::RefPtr<Gtk::Adjustment> _hadj;
+    Glib::RefPtr<Gtk::Adjustment> _vadj;
+
+    Gtk::Grid *_coord_status;
+
+    Gtk::Label *_select_status;
+    Gtk::Label *_coord_status_x;
+    Gtk::Label *_coord_status_y;
+
+    Gtk::Box* _zoom_status_box;
+    Inkscape::UI::Widget::SpinButton *_zoom_status;
+    sigc::connection _zoom_status_input_connection;
+    sigc::connection _zoom_status_output_connection;
+    sigc::connection _zoom_status_value_changed_connection;
+    sigc::connection _zoom_status_populate_popup_connection;
+
+    Gtk::Box* _rotation_status_box;
+    Inkscape::UI::Widget::SpinButton *_rotation_status = nullptr;
+    sigc::connection _rotation_status_input_connection;
+    sigc::connection _rotation_status_output_connection;
+    sigc::connection _rotation_status_value_changed_connection;
+    sigc::connection _rotation_status_populate_popup_connection;
+
+
+    Inkscape::UI::Widget::SelectedStyle *_selected_style;
+
+    /** A grid for display the canvas, rulers, and scrollbars. */
+    Inkscape::UI::Widget::CanvasGrid *_canvas_grid;
+
+    unsigned int _interaction_disabled_counter = 0;
+
+public:
+    double _dt2r;
+
+private:
+    Inkscape::UI::Widget::Canvas *_canvas = nullptr;
+    std::vector<sigc::connection> _connections;
+    Inkscape::PrefObserver _statusbar_preferences_observer;
+    Inkscape::UI::Widget::LayerSelector* _layer_selector;
+    Inkscape::UI::Widget::PageSelector* _page_selector;
+
+public:
+    EgeColorProfTracker* _tracker;
+
+    void setMessage(Inkscape::MessageType type, gchar const *message);
+    void viewSetPosition (Geom::Point p);
+    void letZoomGrabFocus();
+    void getWindowGeometry (gint &x, gint &y, gint &w, gint &h);
+    void setWindowPosition (Geom::Point p);
+    void setWindowSize (gint w, gint h);
+    void setWindowTransient (void *p, int transient_policy);
+    void presentWindow();
+    bool showInfoDialog( Glib::ustring const &message );
+    bool warnDialog (Glib::ustring const &text);
+    Gtk::Toolbar* get_toolbar_by_name(const Glib::ustring& name);
+    void setToolboxFocusTo (gchar const *);
+    void setToolboxAdjustmentValue (gchar const * id, double value);
+    bool isToolboxButtonActive (gchar const *id);
+    void setCoordinateStatus(Geom::Point p);
+    void enableInteraction();
+    void disableInteraction();
+    void updateTitle(gchar const *uri);
+    bool onFocusInEvent(GdkEventFocus *);
+    Inkscape::UI::Dialog::DialogContainer *getDialogContainer();
+    void showNotice(Glib::ustring const &msg, unsigned timeout = 0);
+
+    Gtk::MenuBar *menubar() { return _menubar; }
+
+    void updateNamedview();
+    void update_guides_lock();
+
+    // Canvas Grid Widget
+    void cms_adjust_set_sensitive(bool enabled);
+    bool get_color_prof_adj_enabled() const;
+    void toggle_color_prof_adj();
+    void update_zoom();
+    void update_rotation();
+    void update_rulers();
+    void repack_snaptoolbar();
+
+    void iconify();
+    void maximize();
+    void fullscreen();
+    static gint ruler_event(GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw, bool horiz);
+
+    void layoutWidgets();
+    void toggle_scrollbars();
+    void update_scrollbars(double scale);
+    void toggle_command_palette();
+    void toggle_rulers();
+    void sticky_zoom_toggled();
+    void sticky_zoom_updated();
+
+    Gtk::Widget *get_tool_toolbox() const { return Glib::wrap(tool_toolbox); }
+private:
+    GtkWidget *tool_toolbox;
+    GtkWidget *aux_toolbox;
+    GtkWidget *commands_toolbox;
+    GtkWidget *snap_toolbox;
+    Inkscape::PrefObserver _tb_snap_pos;
+    Inkscape::PrefObserver _tb_icon_sizes1;
+    Inkscape::PrefObserver _tb_icon_sizes2;
+    Inkscape::PrefObserver _tb_visible_buttons;
+    Inkscape::PrefObserver _ds_sticky_zoom;
+
+    void namedviewModified(SPObject *obj, guint flags);
+    int zoom_input(double *new_val);
+    bool zoom_output();
+    void zoom_value_changed();
+    void zoom_menu_handler(double factor);
+    void zoom_populate_popup(Gtk::Menu *menu);
+    bool rotation_output();
+    void rotation_value_changed();
+    void rotation_populate_popup(Gtk::Menu *menu);
+  //void canvas_tbl_size_allocate(Gtk::Allocation &allocation);
+    void update_statusbar_visibility();
+    void apply_ctrlbar_settings();
+
+public:
+    void cms_adjust_toggled();
+private:
+    static void color_profile_event(EgeColorProfTracker *tracker, SPDesktopWidget *dtw);
+    static void ruler_snap_new_guide(SPDesktop *desktop, Geom::Point &event_dt, Geom::Point &normal);
+    static gint event(GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw);
+
+public: // Move to CanvasGrid
+    bool on_ruler_box_button_press_event(GdkEventButton *event, Gtk::Widget *widget, bool horiz);
+    bool on_ruler_box_button_release_event(GdkEventButton *event, Gtk::Widget *widget, bool horiz);
+    bool on_ruler_box_motion_notify_event(GdkEventMotion *event, Gtk::Widget *widget, bool horiz);
+    void on_adjustment_value_changed();
+};
+
+#endif /* !SEEN_SP_DESKTOP_WIDGET_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/widgets/paintdef.cpp b/src/widgets/paintdef.cpp
new file mode 100644
index 0000000..a3fba3f
--- /dev/null
+++ b/src/widgets/paintdef.cpp
@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: GPL-2.0-or-later OR MPL-1.1 OR LGPL-2.1-or-later
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Eek Color Definition.
+ *
+ * The Initial Developer of the Original Code is
+ * Jon A. Cruz.
+ * Portions created by the Initial Developer are Copyright (C) 2006
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#include "paintdef.h"
+
+#include <memory>
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <cstdio>
+#include <glibmm/i18n.h>
+#include <glibmm/stringutils.h>
+#include <glibmm/regex.h>
+
+static char const *mimeOSWB_COLOR = "application/x-oswb-color";
+static char const *mimeX_COLOR = "application/x-color";
+static char const *mimeTEXT = "text/plain";
+
+PaintDef::PaintDef()
+    : description(_("none"))
+    , type(NONE)
+    , rgb({0, 0, 0})
+{
+}
+
+PaintDef::PaintDef(std::array<unsigned, 3> const &rgb, std::string description)
+    : description(std::move(description))
+    , type(RGB)
+    , rgb(rgb)
+{
+}
+
+std::string PaintDef::get_color_id() const
+{
+    if (type == NONE) {
+        return "none";
+    }
+    if (!description.empty() && description[0] != '#') {
+        auto name = Glib::ustring(std::move(description));
+        // Convert description to ascii, strip out symbols, remove duplicate dashes and prefixes
+        static auto const reg1 = Glib::Regex::create("[^[:alnum:]]");
+        name = reg1->replace(name, 0, "-", static_cast<Glib::RegexMatchFlags>(0));
+        static auto const reg2 = Glib::Regex::create("-{2,}");
+        name = reg2->replace(name, 0, "-", static_cast<Glib::RegexMatchFlags>(0));
+        static auto const reg3 = Glib::Regex::create("(^-|-$)");
+        name = reg3->replace(name, 0, "", static_cast<Glib::RegexMatchFlags>(0));
+        // Move important numbers from the start where they are invalid xml, to the end.
+        static auto const reg4 = Glib::Regex::create("^(\\d+)(-?)([^\\d]*)");
+        name = reg4->replace(name, 0, "\\3\\2\\1", static_cast<Glib::RegexMatchFlags>(0));
+        return name.lowercase();
+    }
+    auto [r, g, b] = rgb;
+    char buf[12];
+    std::snprintf(buf, 12, "rgb%02x%02x%02x", r, g, b);
+    return std::string(buf);
+}
+
+std::vector<std::string> const &PaintDef::getMIMETypes()
+{
+    static std::vector<std::string> mimetypes = {mimeOSWB_COLOR, mimeX_COLOR, mimeTEXT};
+    return mimetypes;
+}
+
+std::pair<std::vector<char>, int> PaintDef::getMIMEData(std::string const &type) const
+{
+    auto from_data = [] (void const *p, int len) {
+        std::vector<char> v(len);
+        std::memcpy(v.data(), p, len);
+        return v;
+    };
+
+    auto [r, g, b] = rgb;
+
+    if (type == mimeTEXT) {
+        std::array<char, 8> tmp;
+        std::snprintf(tmp.data(), 8, "#%02x%02x%02x", r, g, b);
+        return std::make_pair(from_data(tmp.data(), 8), 8);
+    } else if (type == mimeX_COLOR) {
+        std::array<uint16_t, 4> tmp = {(uint16_t)((r << 8) | r), (uint16_t)((g << 8) | g), (uint16_t)((b << 8) | b), 0xffff};
+        return std::make_pair(from_data(tmp.data(), 8), 16);
+    } else if (type == mimeOSWB_COLOR) {
+        std::string tmp("<paint>");
+        switch (get_type()) {
+            case PaintDef::NONE:
+                tmp += "<nocolor/>";
+                break;
+            default:
+                tmp += std::string("<color name=\"") + description + "\">";
+                tmp += "<sRGB r=\"";
+                tmp += Glib::Ascii::dtostr(r / 255.0);
+                tmp += "\" g=\"";
+                tmp += Glib::Ascii::dtostr(g / 255.0);
+                tmp += "\" b=\"";
+                tmp += Glib::Ascii::dtostr(b / 255.0);
+                tmp += "\"/>";
+                tmp += "</color>";
+        }
+        tmp += "</paint>";
+        return std::make_pair(from_data(tmp.c_str(), tmp.size()), 8);
+    } else {
+        return {{}, 0};
+    }
+}
+
+bool PaintDef::fromMIMEData(std::string const &type_str, char const *data, int len)
+{
+    if (type_str == mimeTEXT) {
+        // unused
+    } else if (type_str == mimeX_COLOR) {
+        // unused
+    } else if (type_str == mimeOSWB_COLOR) {
+        std::string xml(data, len);
+        if (xml.find("<nocolor/>") != std::string::npos) {
+            type = PaintDef::NONE;
+            rgb = {0, 0, 0};
+            return true;
+        } else if (auto pos = xml.find("<sRGB"); pos != std::string::npos) {
+            std::string srgb = xml.substr(pos, xml.find(">", pos));
+            type = PaintDef::RGB;
+            if (auto numPos = srgb.find("r="); numPos != std::string::npos) {
+                double dbl = Glib::Ascii::strtod(srgb.substr(numPos + 3));
+                rgb[0] = static_cast<int>(255 * dbl);
+            }
+            if (auto numPos = srgb.find("g="); numPos != std::string::npos) {
+                double dbl = Glib::Ascii::strtod(srgb.substr(numPos + 3));
+                rgb[1] = static_cast<int>(255 * dbl);
+            }
+            if (auto numPos = srgb.find("b="); numPos != std::string::npos) {
+                double dbl = Glib::Ascii::strtod(srgb.substr(numPos + 3));
+                rgb[2] = static_cast<int>(255 * dbl);
+            }
+            if (auto pos = xml.find("<color "); pos != std::string::npos) {
+                std::string colorTag = xml.substr(pos, xml.find(">", pos));
+                if (auto namePos = colorTag.find("name="); namePos != std::string::npos) {
+                    char quote = colorTag[namePos + 5];
+                    auto endPos = colorTag.find(quote, namePos + 6);
+                    description = colorTag.substr(namePos + 6, endPos - (namePos + 6));
+                }
+            }
+            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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/paintdef.h b/src/widgets/paintdef.h
new file mode 100644
index 0000000..f66ae03
--- /dev/null
+++ b/src/widgets/paintdef.h
@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: GPL-2.0-or-later OR MPL-1.1 OR LGPL-2.1-or-later
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Eek Color Definition.
+ *
+ * The Initial Developer of the Original Code is
+ * Jon A. Cruz.
+ * Portions created by the Initial Developer are Copyright (C) 2006
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef INKSCAPE_WIDGETS_PAINTDEF_H
+#define INKSCAPE_WIDGETS_PAINTDEF_H
+
+#include <string>
+#include <vector>
+#include <array>
+#include <utility>
+
+/**
+ * Pure data representation of a color definition.
+ */
+class PaintDef
+{
+public:
+    enum ColorType
+    {
+        NONE,
+        RGB
+    };
+
+    /// Create a color of type NONE
+    PaintDef();
+
+    /// Create a color of type RGB
+    PaintDef(std::array<unsigned, 3> const &rgb, std::string description);
+
+    std::string get_color_id() const;
+
+    std::string const &get_description() const { return description; }
+    ColorType get_type() const { return type; }
+    std::array<unsigned, 3> const &get_rgb() const { return rgb; }
+
+    static std::vector<std::string> const &getMIMETypes();
+    std::pair<std::vector<char>, int> getMIMEData(std::string const &type) const;
+    bool fromMIMEData(std::string const &type, char const *data, int len);
+
+protected:
+    std::string description;
+    ColorType type;
+    std::array<unsigned, 3> rgb;
+};
+
+#endif // INKSCAPE_WIDGETS_PAINTDEF_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/widgets/sp-attribute-widget.cpp b/src/widgets/sp-attribute-widget.cpp
new file mode 100644
index 0000000..90ca6ea
--- /dev/null
+++ b/src/widgets/sp-attribute-widget.cpp
@@ -0,0 +1,297 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Base widget for user input of object properties.
+ */
+/* Authors:
+ *  Lauris Kaplinski <lauris@ximian.com>
+ *  Abhishek Sharma
+ *  Kris De Gussem <Kris.DeGussem@gmail.com>
+ *
+ * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2012, authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/i18n.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/grid.h>
+
+#include "sp-attribute-widget.h"
+
+#include "include/macros.h"
+#include "document.h"
+#include "document-undo.h"
+
+#include "include/gtkmm_version.h"
+
+#include "object/sp-object.h"
+
+#include "xml/repr.h"
+
+using Inkscape::DocumentUndo;
+
+/**
+ * Callback for user input in one of the entries.
+ *
+ * sp_attribute_table_entry_changed set the object property
+ * to the new value and updates history. It is a callback from
+ * the entries created by SPAttributeTable.
+ * 
+ * @param editable pointer to the entry box.
+ * @param spat pointer to the SPAttributeTable instance.
+ */
+static void sp_attribute_table_entry_changed (Gtk::Entry *editable, SPAttributeTable *spat);
+/**
+ * Callback for a modification of the selected object (size, color, properties, etc.).
+ *
+ * sp_attribute_table_object_modified rereads the object properties
+ * and shows the values in the entry boxes. It is a callback from a
+ * connection of the SPObject.
+ * 
+ * @param object the SPObject to which this instance is referring to.
+ * @param flags gives the applied modifications
+ * @param spat pointer to the SPAttributeTable instance.
+ */
+static void sp_attribute_table_object_modified (SPObject *object, guint flags, SPAttributeTable *spaw);
+/**
+ * Callback for the deletion of the selected object.
+ *
+ * sp_attribute_table_object_release invalidates all data of 
+ * SPAttributeTable and disables the widget.
+ */
+static void sp_attribute_table_object_release (SPObject */*object*/, SPAttributeTable *spat);
+
+#define XPAD 4
+#define YPAD 2
+
+
+SPAttributeTable::SPAttributeTable () : 
+    _object(nullptr),
+    blocked(false),
+    table(nullptr),
+    _attributes(),
+    _entries(),
+    modified_connection(),
+    release_connection()
+{
+}
+
+SPAttributeTable::SPAttributeTable (SPObject *object, std::vector<Glib::ustring> &labels, std::vector<Glib::ustring> &attributes, GtkWidget* parent) : 
+    _object(nullptr),
+    blocked(false),
+    table(nullptr),
+    _attributes(),
+    _entries(),
+    modified_connection(),
+    release_connection()
+{
+    set_object(object, labels, attributes, parent);
+}
+
+SPAttributeTable::~SPAttributeTable ()
+{
+    clear();
+}
+
+void SPAttributeTable::clear()
+{
+    if (table)
+    {
+        std::vector<Gtk::Widget*> ch = table->get_children();
+        for (int i = (ch.size())-1; i >=0 ; i--)
+        {
+            Gtk::Widget *w = ch[i];
+            ch.pop_back();
+            if (w != nullptr)
+            {
+                try
+                {
+                    sp_signal_disconnect_by_data (w->gobj(), this);
+                    delete w;
+                }
+                catch(...)
+                {
+                }
+            }
+        }
+        ch.clear();
+        _attributes.clear();
+        _entries.clear();
+        
+        delete table;
+        table = nullptr;
+    }
+
+    if (_object)
+    {
+        modified_connection.disconnect();
+        release_connection.disconnect();
+        _object = nullptr;
+    }
+}
+
+void SPAttributeTable::set_object(SPObject *object,
+                            std::vector<Glib::ustring> &labels,
+                            std::vector<Glib::ustring> &attributes,
+                            GtkWidget* parent)
+{
+    g_return_if_fail (!object || !labels.empty() || !attributes.empty());
+    g_return_if_fail (labels.size() == attributes.size());
+
+    clear();
+    _object = object;
+
+    if (object) {
+        blocked = true;
+
+        // Set up object
+        modified_connection = object->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_attribute_table_object_modified), this));
+        release_connection  = object->connectRelease (sigc::bind<1>(sigc::ptr_fun(&sp_attribute_table_object_release), this));
+
+        // Create table
+        table = new Gtk::Grid();
+
+        if (!(parent == nullptr))
+            gtk_container_add(GTK_CONTAINER(parent), (GtkWidget*)table->gobj());
+        
+        // Fill rows
+        _attributes = attributes;
+        for (guint i = 0; i < (attributes.size()); i++) {
+            Gtk::Label *ll = new Gtk::Label (_(labels[i].c_str()));
+            ll->show();
+            ll->set_halign(Gtk::ALIGN_START);
+            ll->set_valign(Gtk::ALIGN_CENTER);
+            ll->set_vexpand(false);
+            ll->set_margin_end(XPAD);
+            ll->set_margin_top(YPAD);
+            ll->set_margin_bottom(YPAD);
+            table->attach(*ll, 0, i, 1, 1);
+
+            Gtk::Entry *ee = new Gtk::Entry();
+            ee->show();
+            const gchar *val = object->getRepr()->attribute(attributes[i].c_str());
+            ee->set_text (val ? val : (const gchar *) "");
+            ee->set_hexpand();
+            ee->set_vexpand(false);
+            ee->set_margin_start(XPAD);
+            ee->set_margin_top(YPAD);
+            ee->set_margin_bottom(YPAD);
+            table->attach(*ee, 1, i, 1, 1);
+
+            _entries.push_back(ee);
+            g_signal_connect ( ee->gobj(), "changed",
+                               G_CALLBACK (sp_attribute_table_entry_changed),
+                               this );
+        }
+        /* Show table */
+        table->show ();
+        blocked = false;
+    }
+}
+
+void SPAttributeTable::change_object(SPObject *object)
+{
+    if (_object)
+    {
+        modified_connection.disconnect();
+        release_connection.disconnect();
+        _object = nullptr;
+    }
+
+    _object = object;
+    if (_object) {
+        blocked = true;
+
+        // Set up object
+        modified_connection = _object->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_attribute_table_object_modified), this));
+        release_connection  = _object->connectRelease (sigc::bind<1>(sigc::ptr_fun(&sp_attribute_table_object_release), this));
+        for (guint i = 0; i < (_attributes.size()); i++) {
+            const gchar *val = _object->getRepr()->attribute(_attributes[i].c_str());
+            _entries[i]->set_text(val ? val : "");
+        }
+        
+        blocked = false;
+    }
+
+}
+
+void SPAttributeTable::reread_properties()
+{
+    blocked = true;
+	for (guint i = 0; i < (_attributes.size()); i++)
+    {
+        const gchar *val = _object->getRepr()->attribute(_attributes[i].c_str());
+        _entries[i]->set_text(val ? val : "");
+    }
+	blocked = false;
+}
+
+static void sp_attribute_table_object_modified ( SPObject */*object*/,
+                                     guint flags,
+                                     SPAttributeTable *spat )
+{
+    if (flags & SP_OBJECT_MODIFIED_FLAG)
+    {
+        std::vector<Glib::ustring> attributes = spat->get_attributes();
+        std::vector<Gtk::Entry *> entries = spat->get_entries();
+        Glib::ustring text="";
+        for (guint i = 0; i < (attributes.size()); i++) {
+            Gtk::Entry* e = entries[i];
+            const gchar *val = spat->_object->getRepr()->attribute(attributes[i].c_str());
+            text = e->get_text ();
+            if (val || !text.empty()) {
+                if (text != val) {
+                    // We are different
+                    spat->blocked = true;
+                    e->set_text (val ? val : (const gchar *) "");
+                    spat->blocked = false;
+                }
+            }
+        }
+    }
+
+} // end of sp_attribute_table_object_modified()
+
+static void sp_attribute_table_entry_changed ( Gtk::Entry *editable,
+                                   SPAttributeTable *spat )
+{
+    if (!spat->blocked)
+    {
+        std::vector<Glib::ustring> attributes = spat->get_attributes();
+        std::vector<Gtk::Entry *> entries = spat->get_entries();
+        for (guint i = 0; i < (attributes.size()); i++) {
+            Gtk::Entry *e = entries[i];
+            if ((GtkWidget*)editable == (GtkWidget*)e->gobj()) {
+                spat->blocked = true;
+                Glib::ustring text = e->get_text ();
+                if (spat->_object) {
+                    spat->_object->getRepr()->setAttribute(attributes[i], text);
+                    DocumentUndo::done(spat->_object->document, _("Set attribute"), "");
+                }
+                spat->blocked = false;
+                return;
+            }
+        }
+        g_warning ("file %s: line %d: Entry signalled change, but there is no such entry", __FILE__, __LINE__);
+    }
+
+} // end of sp_attribute_table_entry_changed()
+
+static void sp_attribute_table_object_release (SPObject */*object*/, SPAttributeTable *spat)
+{
+    std::vector<Glib::ustring> labels;
+    std::vector<Glib::ustring> attributes;
+    spat->set_object (nullptr, labels, attributes, nullptr);
+}
+
+/*
+  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/widgets/sp-attribute-widget.h b/src/widgets/sp-attribute-widget.h
new file mode 100644
index 0000000..891db0a
--- /dev/null
+++ b/src/widgets/sp-attribute-widget.h
@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Widget that listens and modifies repr attributes.
+ */
+/* Authors:
+ *  Lauris Kaplinski <lauris@kaplinski.com>
+ *  Kris De Gussem <Kris.DeGussem@gmail.com>
+ *
+ * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2002,2011-2012 authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_DIALOGS_SP_ATTRIBUTE_WIDGET_H
+#define SEEN_DIALOGS_SP_ATTRIBUTE_WIDGET_H
+
+#include <gtkmm/bin.h>
+#include <cstddef>
+#include <sigc++/connection.h>
+
+namespace Gtk {
+class Entry;
+class Grid;
+}
+
+namespace Inkscape {
+namespace XML {
+class Node;
+}
+}
+
+class  SPObject;
+
+/**
+ * A base class for dialogs to enter the value of several properties.
+ *
+ * SPAttributeTable is used if you want to alter several properties of
+ * an object. For each property, it creates an entry next to a label and
+ * positiones these labels and entries one by one below each other.
+ */
+class SPAttributeTable : public Gtk::Bin {
+public:
+    /**
+     * Constructor defaulting to no content.
+     */
+    SPAttributeTable ();
+    
+    /**
+     * Constructor referring to a specific object.
+     *
+     * This constructor initializes all data fields and creates the necessary widgets.
+     * set_object is called for this purpose.
+     * 
+     * @param object the SPObject to which this instance is referring to. It should be the object that is currently selected and whose properties are being shown by this SPAttributeTable instance.
+     * @param labels list of labels to be shown for the different attributes.
+     * @param attributes list of attributes whose value can be edited.
+     * @param parent the parent object owning the SPAttributeTable instance.
+     * 
+     * @see set_object
+     */
+    SPAttributeTable (SPObject *object, std::vector<Glib::ustring> &labels, std::vector<Glib::ustring> &attributes, GtkWidget* parent);
+    
+    ~SPAttributeTable () override;
+    
+    /**
+     * Sets class properties and creates child widgets
+     *
+     * set_object initializes all data fields, creates links to the
+     * SPOject item and creates the necessary widgets. For n properties
+     * n labels and n entries are created and shown in tabular format.
+     * 
+     * @param object the SPObject to which this instance is referring to. It should be the object that is currently selected and whose properties are being shown by this SPAttribuTable instance.
+     * @param labels list of labels to be shown for the different attributes.
+     * @param attributes list of attributes whose value can be edited.
+     * @param parent the parent object owning the SPAttributeTable instance.
+     */
+    void set_object(SPObject *object, std::vector<Glib::ustring> &labels, std::vector<Glib::ustring> &attributes, GtkWidget* parent);
+    
+    /**
+     * Update values in entry boxes on change of object.
+     *
+     * change_object updates the values of the entry boxes in case the user
+     * of Inkscape selects an other object.
+     * change_object is a subset of set_object and should only be called by
+     * the parent class (holding the SPAttributeTable instance). This function
+     * should only be called when the number of properties/entries nor
+     * the labels do not change.
+     * 
+     * @param object the SPObject to which this instance is referring to. It should be the object that is currently selected and whose properties are being shown by this SPAttribuTable instance.
+     */
+    void change_object(SPObject *object);
+    
+    /**
+     * Clears data of SPAttributeTable instance, destroys all child widgets and closes connections.
+     */
+    void clear();
+    
+    /**
+     * Reads the object attributes.
+     * 
+     * Reads the object attributes and shows the new object attributes in the
+     * entry boxes. Caution: function should only be used when which there is
+     * no change in which objects are selected.
+     */
+    void reread_properties();
+    
+	/**
+     * Gives access to the attributes list.
+     */
+    std::vector<Glib::ustring> get_attributes() {return _attributes;};
+    
+	/**
+     * Gives access to the Gtk::Entry list.
+     */
+    std::vector<Gtk::Entry *> get_entries() {return _entries;};
+    
+	/**
+     * Stores pointer to the selected object.
+     */
+    SPObject *_object;
+    
+	/**
+     * Indicates whether SPAttributeTable is processing callbacks and whether it should accept any updating.
+     */
+    bool blocked;
+
+private:
+    /**
+     * Container widget for the dynamically created child widgets (labels and entry boxes).
+     */
+    Gtk::Grid  *table;
+    
+    /**
+     * List of attributes.
+     * 
+     * _attributes stores the attribute names of the selected object that
+	 * are valid and can be modified through this widget.
+     */
+    std::vector<Glib::ustring> _attributes;
+	/**
+     * List of pointers to the respective entry boxes.
+     * 
+     * _entries stores pointers to the dynamically created entry boxes in which
+	 * the user can midify the attributes of the selected object.
+     */
+    std::vector<Gtk::Entry *> _entries;
+    
+	/**
+     * Sets the callback for a modification of the selection.
+     */
+    sigc::connection modified_connection;
+    
+	/**
+     * Sets the callback for the deletion of the selected object.
+     */
+    sigc::connection release_connection;
+};
+
+#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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/sp-xmlview-tree.cpp b/src/widgets/sp-xmlview-tree.cpp
new file mode 100644
index 0000000..a64e25d
--- /dev/null
+++ b/src/widgets/sp-xmlview-tree.cpp
@@ -0,0 +1,936 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * Specialization of GtkTreeView for the XML tree view
+ *
+ * Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2002 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "sp-xmlview-tree.h"
+
+#include <cstring>
+#include <glibmm/markup.h>
+#include <glibmm/property.h>
+#include <glibmm/ustring.h>
+#include <gmodule.h>
+#include <gtkmm/cellrenderer.h>
+#include <gtkmm/cellrenderertext.h>
+#include <memory>
+#include <string>
+
+#include "ui/syntax.h"
+#include "xml/node-observer.h"
+#include "xml/node.h"
+
+namespace {
+
+struct NodeData
+{
+    SPXMLViewTree *tree;
+    GtkTreeRowReference *rowref;
+    Inkscape::XML::Node *repr;
+    bool expanded = false; //< true if tree view has been expanded to this node
+    bool dragging = false;
+    std::unique_ptr<Inkscape::XML::NodeObserver> observer;
+
+    NodeData(SPXMLViewTree *tree, GtkTreeIter *node, Inkscape::XML::Node *repr);
+    ~NodeData();
+};
+
+// currently dragged node
+Inkscape::XML::Node *dragging_repr = nullptr;
+
+} // namespace
+
+enum { STORE_TEXT_COL = 0, STORE_DATA_COL, STORE_MARKUP_COL, STORE_N_COLS };
+
+static void sp_xmlview_tree_destroy(GtkWidget * object);
+
+static NodeData *sp_xmlview_tree_node_get_data(GtkTreeModel *model, GtkTreeIter *iter);
+
+static void add_node(SPXMLViewTree *tree, GtkTreeIter *parent, GtkTreeIter *before, Inkscape::XML::Node *repr);
+
+static gboolean ref_to_sibling (NodeData *node, Inkscape::XML::Node * ref, GtkTreeIter *);
+static gboolean repr_to_child (NodeData *node, Inkscape::XML::Node * repr, GtkTreeIter *);
+static GtkTreeRowReference *tree_iter_to_ref(SPXMLViewTree *, GtkTreeIter *);
+static gboolean tree_ref_to_iter (SPXMLViewTree * tree, GtkTreeIter* iter, GtkTreeRowReference  *ref);
+
+static gboolean search_equal_func(GtkTreeModel *, gint column, const gchar *key, GtkTreeIter *, gpointer search_data);
+static gboolean foreach_func(GtkTreeModel *, GtkTreePath *, GtkTreeIter *, gpointer user_data);
+
+static void on_row_changed(GtkTreeModel *, GtkTreePath *, GtkTreeIter *, gpointer user_data);
+static void on_drag_begin(GtkWidget *, GdkDragContext *, gpointer userdata);
+static void on_drag_end(GtkWidget *, GdkDragContext *, gpointer userdata);
+static gboolean do_drag_motion(GtkWidget *, GdkDragContext *, gint x, gint y, guint time, gpointer user_data);
+
+static bool get_first_child(NodeData *data, GtkTreeIter *child_iter);
+static void remove_dummy_rows(GtkTreeStore *store, GtkTreeIter *iter);
+static void sp_remove_newlines_and_tabs(std::string &val, size_t const maxlen = 200);
+
+namespace {
+
+static auto null_to_empty(char const *str)
+{
+    return str ? str : "";
+}
+
+class ElementNodeObserver final : public Inkscape::XML::NodeObserver
+{
+    NodeData *_nodedata;
+
+public:
+    ElementNodeObserver(NodeData *nodedata)
+        : _nodedata(nodedata)
+    {}
+
+    void notifyChildAdded(Inkscape::XML::Node&, Inkscape::XML::Node &child_, Inkscape::XML::Node *ref) override
+    {
+        GtkTreeIter before;
+        Inkscape::XML::Node *child = &child_;
+
+        if (_nodedata->tree->blocked) return;
+
+        if (!ref_to_sibling (_nodedata, ref, &before)) {
+            return;
+        }
+
+        GtkTreeIter data_iter;
+        tree_ref_to_iter(_nodedata->tree, &data_iter,  _nodedata->rowref);
+
+        if (!_nodedata->expanded) {
+            auto model = GTK_TREE_MODEL(_nodedata->tree->store);
+            GtkTreeIter childiter;
+            if (!gtk_tree_model_iter_children(model, &childiter, &data_iter)) {
+                // no children yet, add a dummy
+                child = nullptr;
+            } else if (sp_xmlview_tree_node_get_repr(model, &childiter) == nullptr) {
+                // already has a dummy child
+                return;
+            }
+        }
+
+        add_node(_nodedata->tree, &data_iter, &before, child);
+    }
+
+    void notifyAttributeChanged(Inkscape::XML::Node &node, GQuark key_, Inkscape::Util::ptr_shared,
+                                Inkscape::Util::ptr_shared) override
+    {
+        auto const key = g_quark_to_string(key_);
+        if (std::strcmp(key, "id") != 0 && std::strcmp(key, "inkscape:label") != 0)
+            return;
+        elementAttrOrNameChangedUpdate(&node);
+    }
+
+    void notifyElementNameChanged(Inkscape::XML::Node &node, GQuark, GQuark) override
+    {
+        elementAttrOrNameChangedUpdate(&node);
+    }
+
+    void notifyChildOrderChanged(Inkscape::XML::Node &, Inkscape::XML::Node &child, Inkscape::XML::Node *,
+                                 Inkscape::XML::Node *newref) override
+    {
+        GtkTreeIter before, node;
+
+        if (_nodedata->tree->blocked)
+            return;
+
+        ref_to_sibling(_nodedata, newref, &before);
+        repr_to_child(_nodedata, &child, &node);
+
+        if (gtk_tree_store_iter_is_valid(_nodedata->tree->store, &before)) {
+            gtk_tree_store_move_before(_nodedata->tree->store, &node, &before);
+        } else {
+            repr_to_child(_nodedata, newref, &before);
+            gtk_tree_store_move_after(_nodedata->tree->store, &node, &before);
+        }
+    }
+
+    void notifyChildRemoved(Inkscape::XML::Node &repr, Inkscape::XML::Node &child, Inkscape::XML::Node *) override
+    {
+        if (_nodedata->tree->blocked)
+            return;
+
+        GtkTreeIter iter;
+        if (repr_to_child(_nodedata, &child, &iter)) {
+            delete sp_xmlview_tree_node_get_data(GTK_TREE_MODEL(_nodedata->tree->store), &iter);
+            gtk_tree_store_remove(_nodedata->tree->store, &iter);
+        } else if (!repr.firstChild() && get_first_child(_nodedata, &iter)) {
+            // remove dummy when all children gone
+            remove_dummy_rows(_nodedata->tree->store, &iter);
+        } else {
+            return;
+        }
+
+#ifndef GTK_ISSUE_2510_IS_FIXED
+        // https://gitlab.gnome.org/GNOME/gtk/issues/2510
+        gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(GTK_TREE_VIEW(_nodedata->tree)));
+#endif
+    }
+
+    void elementAttrOrNameChangedUpdate(Inkscape::XML::Node *repr)
+    {
+        if (_nodedata->tree->blocked) {
+            return;
+        }
+
+        auto node_name = Glib::ustring(null_to_empty(repr->name()));
+        auto pos = node_name.find("svg:");
+        if (pos != Glib::ustring::npos) {
+            // Do not decorate element names the with default namespace "svg"; it is just visual noise.
+            node_name.erase(pos, 4);
+        }
+
+        // Build a plain-text and a markup-enabled representation of the node.
+        auto &formatter = *_nodedata->tree->formatter;
+        auto display_text = Glib::ustring::compose("<%1", node_name);
+        formatter.openTag(node_name.c_str());
+
+        if (auto id_value = repr->attribute("id")) {
+            display_text += Glib::ustring::compose(" id=\"%1\"", id_value);
+            formatter.addAttribute("id", id_value);
+        }
+        if (auto label_value = repr->attribute("inkscape:label")) {
+            display_text += Glib::ustring::compose(" inkscape:label=\"%1\"", label_value);
+            formatter.addAttribute("inkscape:label", label_value);
+        }
+        display_text += ">";
+        auto markup = formatter.finishTag();
+
+        GtkTreeIter iter;
+        if (tree_ref_to_iter(_nodedata->tree, &iter, _nodedata->rowref)) {
+            gtk_tree_store_set(GTK_TREE_STORE(_nodedata->tree->store), &iter, STORE_TEXT_COL, display_text.c_str(), -1);
+            gtk_tree_store_set(GTK_TREE_STORE(_nodedata->tree->store), &iter, STORE_MARKUP_COL, markup.c_str(), -1);
+        }
+    }
+};
+
+class TextNodeObserver final : public Inkscape::XML::NodeObserver
+{
+    NodeData *_nodedata;
+
+public:
+    TextNodeObserver(NodeData *nodedata)
+        : _nodedata(nodedata)
+    {}
+
+    void notifyContentChanged(Inkscape::XML::Node &, Inkscape::Util::ptr_shared,
+                              Inkscape::Util::ptr_shared new_content) override
+    {
+        if (_nodedata->tree->blocked)
+            return;
+
+        auto text_content = std::string("\"").append(null_to_empty(new_content.pointer())).append("\"");
+        sp_remove_newlines_and_tabs(text_content);
+
+        auto &formatter = *_nodedata->tree->formatter;
+        auto markup = formatter.formatContent(text_content.c_str(), false);
+
+        GtkTreeIter iter;
+        if (tree_ref_to_iter(_nodedata->tree, &iter, _nodedata->rowref)) {
+            gtk_tree_store_set(GTK_TREE_STORE(_nodedata->tree->store), &iter, STORE_TEXT_COL, text_content.c_str(), -1);
+            gtk_tree_store_set(GTK_TREE_STORE(_nodedata->tree->store), &iter, STORE_MARKUP_COL, markup.c_str(), -1);
+        }
+    }
+};
+
+class CommentNodeObserver final : public Inkscape::XML::NodeObserver
+{
+    NodeData *_nodedata;
+
+public:
+    CommentNodeObserver(NodeData *nodedata)
+        : _nodedata(nodedata)
+    {}
+    void notifyContentChanged(Inkscape::XML::Node &, Inkscape::Util::ptr_shared,
+                              Inkscape::Util::ptr_shared new_content) override
+    {
+        if (_nodedata->tree->blocked)
+            return;
+
+        auto comment = std::string("<!--").append(null_to_empty(new_content.pointer())).append("-->");
+        sp_remove_newlines_and_tabs(comment);
+
+        auto &formatter = *_nodedata->tree->formatter;
+        auto markup = formatter.formatComment(comment.c_str(), false);
+
+        GtkTreeIter iter;
+        if (tree_ref_to_iter(_nodedata->tree, &iter, _nodedata->rowref)) {
+            gtk_tree_store_set(GTK_TREE_STORE(_nodedata->tree->store), &iter, STORE_TEXT_COL, comment.c_str(), -1);
+            gtk_tree_store_set(GTK_TREE_STORE(_nodedata->tree->store), &iter, STORE_MARKUP_COL, markup.c_str(), -1);
+        }
+    }
+};
+
+class PINodeObserver final : public Inkscape::XML::NodeObserver
+{
+    NodeData *_nodedata;
+
+public:
+    PINodeObserver(NodeData *nodedata)
+        : _nodedata(nodedata)
+    {}
+    void notifyContentChanged(Inkscape::XML::Node &repr, Inkscape::Util::ptr_shared,
+                              Inkscape::Util::ptr_shared new_content) override
+    {
+        if (_nodedata->tree->blocked)
+            return;
+
+        auto processing_instr = std::string("<?").append(repr.name()).append(" ").append(null_to_empty(new_content.pointer())).append("?>");
+        sp_remove_newlines_and_tabs(processing_instr);
+
+        auto &formatter = *_nodedata->tree->formatter;
+        auto markup = formatter.formatProlog(processing_instr.c_str());
+
+        GtkTreeIter iter;
+        if (tree_ref_to_iter(_nodedata->tree, &iter, _nodedata->rowref)) {
+            gtk_tree_store_set(GTK_TREE_STORE(_nodedata->tree->store), &iter, STORE_TEXT_COL, processing_instr.c_str(), -1);
+            gtk_tree_store_set(GTK_TREE_STORE(_nodedata->tree->store), &iter, STORE_MARKUP_COL, markup.c_str(), -1);
+        }
+    }
+};
+
+} // namespace
+
+/**
+ * Get an iterator to the first child of `data`
+ * @param data handle which references a row
+ * @param[out] child_iter On success: valid iterator to first child
+ * @return False if the node has no children
+ */
+static bool get_first_child(NodeData *data, GtkTreeIter *child_iter)
+{
+    GtkTreeIter iter;
+    return tree_ref_to_iter(data->tree, &iter, data->rowref) &&
+           gtk_tree_model_iter_children(GTK_TREE_MODEL(data->tree->store), child_iter, &iter);
+}
+
+/**
+ * @param iter First dummy row on that level
+ * @pre all rows on the same level are dummies
+ * @pre iter is valid
+ * @post iter is invalid
+ * @post level is empty
+ */
+static void remove_dummy_rows(GtkTreeStore *store, GtkTreeIter *iter)
+{
+    do {
+        g_assert(nullptr == sp_xmlview_tree_node_get_data(GTK_TREE_MODEL(store), iter));
+        gtk_tree_store_remove(store, iter);
+    } while (gtk_tree_store_iter_is_valid(store, iter));
+}
+
+static gboolean on_test_expand_row( //
+    GtkTreeView *tree_view,         //
+    GtkTreeIter *iter,              //
+    GtkTreePath *path,              //
+    gpointer)
+{
+    auto tree = SP_XMLVIEW_TREE(tree_view);
+    auto model = GTK_TREE_MODEL(tree->store);
+
+    GtkTreeIter childiter;
+    bool has_children = gtk_tree_model_iter_children(model, &childiter, iter);
+    g_assert(has_children);
+
+    if (sp_xmlview_tree_node_get_repr(model, &childiter) == nullptr) {
+        NodeData *data = sp_xmlview_tree_node_get_data(model, iter);
+
+        remove_dummy_rows(tree->store, &childiter);
+
+        // insert real rows
+        data->expanded = true;
+        ElementNodeObserver e(data);
+        data->repr->synthesizeEvents(e);
+    }
+
+    return false;
+}
+
+/** Node name renderer for XML tree.
+ *  It knows to use markup, but falls back to plain text for selected nodes.
+ */
+class NodeRenderer : public Gtk::CellRendererText {
+public:
+    NodeRenderer():
+        Glib::ObjectBase(typeid(CellRendererText)),
+        Gtk::CellRendererText(),
+        _property_plain_text(*this, "plain", "-") {}
+
+    // "text" and "markup" properties from CellRendererText are in use for marked up text;
+    // we need a separate property for plain text (placeholder_text could be hijacked potentially)
+    Glib::Property<Glib::ustring> _property_plain_text;
+
+    void render_vfunc(const Cairo::RefPtr<Cairo::Context>& ctx,
+                      Gtk::Widget& widget,
+                      const Gdk::Rectangle& background_area,
+                      const Gdk::Rectangle& cell_area,
+                      Gtk::CellRendererState flags) override {
+        if (flags & Gtk::CELL_RENDERER_SELECTED) {
+            // use plain text instead of marked up text to render selected nodes, so they are legible
+            property_text() = _property_plain_text.get_value();
+        }
+        Gtk::CellRendererText::render_vfunc(ctx, widget, background_area, cell_area, flags);
+    }
+};
+
+GtkWidget *sp_xmlview_tree_new(Inkscape::XML::Node * repr, void * /*factory*/, void * /*data*/)
+{
+    SPXMLViewTree *tree = SP_XMLVIEW_TREE(g_object_new (SP_TYPE_XMLVIEW_TREE, nullptr));
+    tree->_tree_move = new sigc::signal<void ()>();
+
+    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(tree), FALSE);
+    gtk_tree_view_set_reorderable (GTK_TREE_VIEW(tree), TRUE);
+    gtk_tree_view_set_enable_search (GTK_TREE_VIEW(tree), TRUE);
+    gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW(tree), search_equal_func, nullptr, nullptr);
+
+    auto r = new NodeRenderer();
+    tree->renderer = r;
+
+    GtkCellRenderer* renderer = r->Gtk::CellRenderer::gobj();
+    GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("", renderer,
+        "markup", STORE_MARKUP_COL, // marked up text for decorated color output
+        "plain", STORE_TEXT_COL,    // plain text for searching and rendering selected nodes
+        nullptr);
+    gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
+    gtk_cell_renderer_set_padding (renderer, 2, 0);
+    gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
+
+    sp_xmlview_tree_set_repr (tree, repr);
+
+    g_signal_connect(GTK_TREE_VIEW(tree), "drag-begin", G_CALLBACK(on_drag_begin), tree);
+    g_signal_connect(GTK_TREE_VIEW(tree), "drag-end", G_CALLBACK(on_drag_end), tree);
+    g_signal_connect(GTK_TREE_VIEW(tree), "drag-motion",  G_CALLBACK(do_drag_motion), tree);
+    g_signal_connect(GTK_TREE_VIEW(tree), "test-expand-row", G_CALLBACK(on_test_expand_row), nullptr);
+
+    tree->formatter = new Inkscape::UI::Syntax::XMLFormatter();
+
+    return GTK_WIDGET(tree);
+}
+
+G_DEFINE_TYPE(SPXMLViewTree, sp_xmlview_tree, GTK_TYPE_TREE_VIEW);
+
+void sp_xmlview_tree_class_init(SPXMLViewTreeClass * klass)
+{
+    auto widget_class = GTK_WIDGET_CLASS(klass);
+    widget_class->destroy = sp_xmlview_tree_destroy;
+}
+
+void
+sp_xmlview_tree_init (SPXMLViewTree * tree)
+{
+	tree->repr = nullptr;
+	tree->blocked = 0;
+}
+
+void sp_xmlview_tree_destroy(GtkWidget * object)
+{
+	SPXMLViewTree * tree = SP_XMLVIEW_TREE (object);
+
+    delete tree->renderer;
+    tree->renderer = nullptr;
+    delete tree->formatter;
+    tree->formatter = nullptr;
+    delete tree->_tree_move;
+    tree->_tree_move = nullptr;
+
+	sp_xmlview_tree_set_repr (tree, nullptr);
+
+	GTK_WIDGET_CLASS(sp_xmlview_tree_parent_class)->destroy (object);
+}
+
+/*
+ * Add a new row to the tree
+ */
+void
+add_node (SPXMLViewTree * tree, GtkTreeIter *parent, GtkTreeIter *before, Inkscape::XML::Node * repr)
+{
+	g_assert (tree != nullptr);
+
+    if (before && !gtk_tree_store_iter_is_valid(tree->store, before)) {
+        before = nullptr;
+    }
+
+	GtkTreeIter iter;
+    gtk_tree_store_insert_before (tree->store, &iter, parent, before);
+
+    if (!gtk_tree_store_iter_is_valid(tree->store, &iter)) {
+        return;
+    }
+
+    if (!repr) {
+        // no need to store any data
+        return;
+    }
+
+    auto data = new NodeData(tree, &iter, repr);
+
+    g_assert(data != nullptr);
+
+    gtk_tree_store_set(tree->store, &iter, STORE_DATA_COL, data, -1);
+
+    if (repr->type() == Inkscape::XML::NodeType::TEXT_NODE) {
+        data->observer = std::make_unique<TextNodeObserver>(data);
+    } else if (repr->type() == Inkscape::XML::NodeType::COMMENT_NODE) {
+        data->observer = std::make_unique<CommentNodeObserver>(data);
+    } else if (repr->type() == Inkscape::XML::NodeType::PI_NODE) {
+        data->observer = std::make_unique<PINodeObserver>(data);
+    } else if (repr->type() == Inkscape::XML::NodeType::ELEMENT_NODE) {
+        data->observer = std::make_unique<ElementNodeObserver>(data);
+    }
+
+    if (data->observer) {
+        /* cheat a little to get the text updated on nodes without id */
+        if (repr->type() == Inkscape::XML::NodeType::ELEMENT_NODE && repr->attribute("id") == nullptr) {
+            data->observer->notifyAttributeChanged(*repr, g_quark_from_static_string("id"),
+                                                   Inkscape::Util::ptr_shared(), Inkscape::Util::ptr_shared());
+        }
+        repr->addObserver(*data->observer);
+        repr->synthesizeEvents(*data->observer);
+    }
+}
+
+static gboolean remove_all_listeners(GtkTreeModel *model, GtkTreePath *, GtkTreeIter *iter, gpointer)
+{
+    NodeData *data = sp_xmlview_tree_node_get_data(model, iter);
+    delete data;
+    return false;
+}
+
+NodeData::NodeData(SPXMLViewTree *tree, GtkTreeIter *iter, Inkscape::XML::Node *repr)
+    : tree(tree)
+    , rowref(tree_iter_to_ref(tree, iter))
+    , repr(repr)
+{
+    if (repr) {
+        Inkscape::GC::anchor(repr);
+    }
+}
+
+NodeData::~NodeData()
+{
+    if (repr) {
+        if (observer) {
+            repr->removeObserver(*observer);
+        }
+        Inkscape::GC::release(repr);
+    }
+    gtk_tree_row_reference_free(rowref);
+}
+
+/**
+ * Truncate `val` to `maxlen` unicode characters and replace newlines and tabs
+ * with placeholder symbols. The string is modified in place.
+ * @param[in,out] val String in UTF-8 encoding
+ */
+static void sp_remove_newlines_and_tabs(std::string &val, size_t const maxlen)
+{
+    if (g_utf8_strlen(val.data(), maxlen * 2) > maxlen) {
+        size_t newlen = g_utf8_offset_to_pointer(val.data(), maxlen - 3) - val.data();
+        val.resize(newlen);
+        val.append("…");
+    }
+
+    struct
+    {
+        const char *query;
+        const char *replacement;
+    } replacements[] = {
+        {"\r\n", "⏎"},
+        {"\n", "⏎"},
+        {"\t", "⇥"},
+    };
+
+    for (auto const &item : replacements) {
+        for (size_t pos = 0; (pos = val.find(item.query, pos)) != std::string::npos;) {
+            val.replace(pos, strlen(item.query), item.replacement);
+        }
+    }
+}
+
+/*
+ * Save the source path on drag start, will need it in on_row_changed() when moving a row
+ */
+void on_drag_begin(GtkWidget *, GdkDragContext *, gpointer userdata)
+{
+    SPXMLViewTree *tree = static_cast<SPXMLViewTree *>(userdata);
+    if (!tree) {
+        return;
+    }
+
+    GtkTreeModel *model = nullptr;
+    GtkTreeIter iter;
+    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
+    if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
+        NodeData *data = sp_xmlview_tree_node_get_data(model, &iter);
+        if (data) {
+            data->dragging = true;
+            dragging_repr = data->repr;
+        }
+    }
+}
+
+/**
+ * Finalize what happened in `on_row_changed` and clean up what was set up in `on_drag_begin`
+ */
+void on_drag_end(GtkWidget *, GdkDragContext *, gpointer userdata)
+{
+    if (!dragging_repr)
+        return;
+
+    auto tree = static_cast<SPXMLViewTree *>(userdata);
+    auto selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
+    bool failed = false;
+
+    GtkTreeIter iter;
+    if (sp_xmlview_tree_get_repr_node(tree, dragging_repr, &iter)) {
+        NodeData *data = sp_xmlview_tree_node_get_data(GTK_TREE_MODEL(tree->store), &iter);
+
+        if (data && data->dragging) {
+            // dragging flag was not cleared in `on_row_changed`, this indicates a failed drag
+            data->dragging = false;
+            failed = true;
+        } else {
+            // Reselect the dragged row
+            gtk_tree_selection_select_iter(selection, &iter);
+        }
+    } else {
+#ifndef GTK_ISSUE_2510_IS_FIXED
+        // https://gitlab.gnome.org/GNOME/gtk/issues/2510
+        gtk_tree_selection_unselect_all(selection);
+#endif
+    }
+
+    dragging_repr = nullptr;
+
+    if (!failed) {
+        // Signal that a drag and drop has completed successfully
+        tree->_tree_move->emit();
+    }
+}
+
+/*
+ * Main drag & drop function
+ * Get the old and new paths, and change the Inkscape::XML::Node repr's
+ */
+void on_row_changed(GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data)
+{
+    NodeData *data = sp_xmlview_tree_node_get_data(tree_model, iter);
+
+    if (!data || !data->dragging) {
+        return;
+    }
+    data->dragging = false;
+
+    SPXMLViewTree *tree = SP_XMLVIEW_TREE(user_data);
+
+    gtk_tree_row_reference_free(data->rowref);
+    data->rowref = tree_iter_to_ref(tree, iter);
+
+    GtkTreeIter new_parent;
+    if (!gtk_tree_model_iter_parent(tree_model, &new_parent, iter)) {
+        //No parent of drop location
+        return;
+    }
+
+    Inkscape::XML::Node *repr = sp_xmlview_tree_node_get_repr(tree_model, iter);
+    Inkscape::XML::Node *before_repr = nullptr;
+
+    // Find the sibling node before iter
+    GtkTreeIter before_iter = *iter;
+    if (gtk_tree_model_iter_previous(tree_model, &before_iter)) {
+        before_repr = sp_xmlview_tree_node_get_repr(tree_model, &before_iter);
+    }
+
+    // Drop onto oneself causes assert in changeOrder() below, ignore
+    if (repr == before_repr)
+        return;
+
+    auto repr_old_parent = repr->parent();
+    auto repr_new_parent = sp_xmlview_tree_node_get_repr(tree_model, &new_parent);
+
+    tree->blocked++;
+
+    if (repr_old_parent == repr_new_parent) {
+        repr_old_parent->changeOrder(repr, before_repr);
+    } else {
+        repr_old_parent->removeChild(repr);
+        repr_new_parent->addChild(repr, before_repr);
+    }
+
+    NodeData *data_new_parent = sp_xmlview_tree_node_get_data(tree_model, &new_parent);
+    if (data_new_parent && data_new_parent->expanded) {
+        // Reselect the dragged row in `on_drag_end` instead of here, because of
+        // https://gitlab.gnome.org/GNOME/gtk/-/issues/2510
+    } else {
+        // convert to dummy node
+        delete data;
+        gtk_tree_store_set(tree->store, iter, STORE_DATA_COL, nullptr, -1);
+    }
+
+    tree->blocked--;
+}
+
+/*
+ * Set iter to ref or node data's child with the same repr or first child
+ */
+gboolean ref_to_sibling (NodeData *data, Inkscape::XML::Node *repr, GtkTreeIter *iter)
+{
+	if (repr) {
+		if (!repr_to_child (data, repr, iter)) {
+            return false;
+        }
+        gtk_tree_model_iter_next (GTK_TREE_MODEL(data->tree->store), iter);
+	} else {
+	    GtkTreeIter data_iter;
+	    if (!tree_ref_to_iter(data->tree, &data_iter,  data->rowref)) {
+	        return false;
+	    }
+	    gtk_tree_model_iter_children(GTK_TREE_MODEL(data->tree->store), iter, &data_iter);
+	}
+	return true;
+}
+
+/*
+ * Set iter to the node data's child with the same repr
+ */
+gboolean repr_to_child (NodeData *data, Inkscape::XML::Node * repr, GtkTreeIter *iter)
+{
+    GtkTreeIter data_iter;
+    GtkTreeModel *model = GTK_TREE_MODEL(data->tree->store);
+    gboolean valid = false;
+
+    if (!tree_ref_to_iter(data->tree, &data_iter, data->rowref)) {
+        return false;
+    }
+
+    /*
+     * The node we are looking for is likely to be the last one, so check it first.
+     */
+    gint n_children = gtk_tree_model_iter_n_children (model, &data_iter);
+    if (n_children > 1) {
+        valid = gtk_tree_model_iter_nth_child (model, iter, &data_iter, n_children-1);
+        if (valid && sp_xmlview_tree_node_get_repr (model, iter) == repr) {
+            //g_message("repr_to_child hit %d", n_children);
+            return valid;
+        }
+    }
+
+    valid = gtk_tree_model_iter_children(model, iter, &data_iter);
+    while (valid && sp_xmlview_tree_node_get_repr (model, iter) != repr) {
+        valid = gtk_tree_model_iter_next(model, iter);
+	}
+
+    return valid;
+}
+
+/*
+ * Get a matching GtkTreeRowReference for a GtkTreeIter
+ */
+GtkTreeRowReference  *tree_iter_to_ref (SPXMLViewTree * tree, GtkTreeIter* iter)
+{
+    GtkTreePath* path = gtk_tree_model_get_path(GTK_TREE_MODEL(tree->store), iter);
+    GtkTreeRowReference  *ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(tree->store), path);
+    gtk_tree_path_free(path);
+
+    return ref;
+}
+
+/*
+ * Get a matching GtkTreeIter for a GtkTreeRowReference
+ */
+gboolean tree_ref_to_iter (SPXMLViewTree * tree, GtkTreeIter* iter, GtkTreeRowReference  *ref)
+{
+    GtkTreePath* path = gtk_tree_row_reference_get_path(ref);
+    if (!path) {
+        return false;
+    }
+    gboolean const valid = //
+        gtk_tree_model_get_iter(GTK_TREE_MODEL(tree->store), iter, path);
+    gtk_tree_path_free(path);
+
+    return valid;
+}
+
+/*
+ * Disable drag and drop target on : root node and non-element nodes
+ */
+gboolean do_drag_motion(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time, gpointer user_data)
+{
+    GtkTreePath *path = nullptr;
+    GtkTreeViewDropPosition pos;
+    gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW(widget), x, y, &path, &pos);
+
+    int action = 0;
+
+    if (!dragging_repr) {
+        goto finally;
+    }
+
+    if (path) {
+        SPXMLViewTree *tree = SP_XMLVIEW_TREE(user_data);
+        GtkTreeIter iter;
+        gtk_tree_model_get_iter(GTK_TREE_MODEL(tree->store), &iter, path);
+        auto repr = sp_xmlview_tree_node_get_repr(GTK_TREE_MODEL(tree->store), &iter);
+
+        bool const drop_into = pos != GTK_TREE_VIEW_DROP_BEFORE && //
+                               pos != GTK_TREE_VIEW_DROP_AFTER;
+
+        // 0. don't drop on self (also handled by on_row_changed but nice to not have drop highlight for it)
+        if (repr == dragging_repr) {
+            goto finally;
+        }
+
+        // 1. only xml elements can have children
+        if (drop_into && repr->type() != Inkscape::XML::NodeType::ELEMENT_NODE) {
+            goto finally;
+        }
+
+        // 3. elements must be at least children of the root <svg:svg> element
+        if (gtk_tree_path_get_depth(path) < 2) {
+            goto finally;
+        }
+
+        // 4. drag node specific limitations
+        {
+            // nodes which can't be re-parented (because the document holds pointers to them which must stay valid)
+            static GQuark const CODE_sodipodi_namedview = g_quark_from_static_string("sodipodi:namedview");
+            static GQuark const CODE_svg_defs = g_quark_from_static_string("svg:defs");
+
+            bool const no_reparenting = dragging_repr->code() == CODE_sodipodi_namedview || //
+                                        dragging_repr->code() == CODE_svg_defs;
+
+            if (no_reparenting && (drop_into || dragging_repr->parent() != repr->parent())) {
+                goto finally;
+            }
+        }
+
+        action = GDK_ACTION_MOVE;
+    }
+
+finally:
+    if (action == 0) {
+        // remove drop highlight
+        gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(widget), nullptr, pos /* ignored */);
+    }
+
+    gtk_tree_path_free(path);
+    gdk_drag_status (context, (GdkDragAction)action, time);
+
+    return (action == 0);
+}
+
+/*
+ * Set the tree selection and scroll to the row with the given repr
+ */
+void
+sp_xmlview_tree_set_repr (SPXMLViewTree * tree, Inkscape::XML::Node * repr)
+{
+    if ( tree->repr == repr ) return;
+
+    if (tree->store) {
+        gtk_tree_view_set_model(GTK_TREE_VIEW(tree), nullptr);
+        gtk_tree_model_foreach(GTK_TREE_MODEL(tree->store), remove_all_listeners, nullptr);
+        g_object_unref(tree->store);
+        tree->store = nullptr;
+    }
+
+    if (tree->repr) {
+        Inkscape::GC::release(tree->repr);
+    }
+    tree->repr = repr;
+    if (repr) {
+        tree->store = gtk_tree_store_new(STORE_N_COLS, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING);
+
+        Inkscape::GC::anchor(repr);
+        add_node(tree, nullptr, nullptr, repr);
+
+        // Set the tree model here, after all data is inserted
+        gtk_tree_view_set_model (GTK_TREE_VIEW(tree), GTK_TREE_MODEL(tree->store));
+        g_signal_connect(G_OBJECT(tree->store), "row-changed", G_CALLBACK(on_row_changed), tree);
+
+        GtkTreePath *path = gtk_tree_path_new_from_indices(0, -1);
+        gtk_tree_view_expand_to_path (GTK_TREE_VIEW(tree), path);
+        gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(tree), path, nullptr, true, 0.5, 0.0);
+        gtk_tree_path_free(path);
+    }
+}
+
+/*
+ * Return the node data at a given GtkTreeIter position
+ */
+NodeData *sp_xmlview_tree_node_get_data(GtkTreeModel *model, GtkTreeIter *iter)
+{
+    NodeData *data = nullptr;
+    gtk_tree_model_get(model, iter, STORE_DATA_COL, &data, -1);
+    return data;
+}
+
+/*
+ * Return the repr at a given GtkTreeIter position
+ */
+Inkscape::XML::Node *
+sp_xmlview_tree_node_get_repr (GtkTreeModel *model, GtkTreeIter * iter)
+{
+    NodeData *data = sp_xmlview_tree_node_get_data(model, iter);
+    return data ? data->repr : nullptr;
+}
+
+struct IterByReprData {
+    const Inkscape::XML::Node *repr; //< in
+    GtkTreeIter *iter;               //< out
+};
+
+/*
+ * Find a GtkTreeIter position in the tree by repr
+ * @return True if the node was found
+ */
+gboolean
+sp_xmlview_tree_get_repr_node (SPXMLViewTree * tree, Inkscape::XML::Node * repr, GtkTreeIter *iter)
+{
+    iter->stamp = 0; // invalidate iterator
+    IterByReprData funcdata = { repr, iter };
+    gtk_tree_model_foreach(GTK_TREE_MODEL(tree->store), foreach_func, &funcdata);
+    return iter->stamp != 0;
+}
+
+gboolean foreach_func(GtkTreeModel *model, GtkTreePath * /*path*/, GtkTreeIter *iter, gpointer user_data)
+{
+    auto funcdata = static_cast<IterByReprData *>(user_data);
+    if (sp_xmlview_tree_node_get_repr(model, iter) == funcdata->repr) {
+        *funcdata->iter = *iter;
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+/*
+ * Callback function for string searches in the tree
+ * Return a match on any substring
+ */
+gboolean search_equal_func(GtkTreeModel *model, gint /*column*/, const gchar *key, GtkTreeIter *iter, gpointer /*search_data*/)
+{
+    gchar *text = nullptr;
+    gtk_tree_model_get(model, iter, STORE_TEXT_COL, &text, -1);
+
+    gboolean match = (strstr(text, key) != nullptr);
+
+    g_free(text);
+
+    return !match;
+}
+
+/*
+  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:fileencoding=utf-8 :
diff --git a/src/widgets/sp-xmlview-tree.h b/src/widgets/sp-xmlview-tree.h
new file mode 100644
index 0000000..b9b2037
--- /dev/null
+++ b/src/widgets/sp-xmlview-tree.h
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2002 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_SP_XMLVIEW_TREE_H
+#define SEEN_SP_XMLVIEW_TREE_H
+
+#include <gtk/gtk.h>
+#include <glib.h>
+#include <gtkmm/cellrenderertext.h>
+
+namespace Inkscape::XML {
+class Node;
+}
+
+/**
+ * Specialization of GtkTreeView for the XML editor
+ */
+
+#define SP_TYPE_XMLVIEW_TREE (sp_xmlview_tree_get_type ())
+#define SP_XMLVIEW_TREE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_XMLVIEW_TREE, SPXMLViewTree))
+#define SP_IS_XMLVIEW_TREE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_XMLVIEW_TREE))
+#define SP_XMLVIEW_TREE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_XMLVIEW_TREE))
+
+struct SPXMLViewTree;
+struct SPXMLViewTreeClass;
+namespace Inkscape::UI::Syntax { class XMLFormatter; }
+
+class SPXMLViewTree
+{
+public:
+    GtkTreeView tree;
+    GtkTreeStore *store;
+    Inkscape::XML::Node * repr;
+    gint blocked;
+    Gtk::CellRendererText* renderer;
+    Inkscape::UI::Syntax::XMLFormatter* formatter;
+
+    sigc::connection connectTreeMove(const sigc::slot<void ()> &slot)
+    {
+        return _tree_move->connect(slot);
+    }
+// private: Make private and not-pointer when refactoring to C++
+    sigc::signal<void ()> *_tree_move;
+};
+
+struct SPXMLViewTreeClass
+{
+	GtkTreeViewClass parent_class;
+};
+
+GType sp_xmlview_tree_get_type ();
+GtkWidget * sp_xmlview_tree_new (Inkscape::XML::Node * repr, void * factory, void * data);
+
+#define SP_XMLVIEW_TREE_REPR(tree) (SP_XMLVIEW_TREE (tree)->repr)
+
+void sp_xmlview_tree_set_repr (SPXMLViewTree * tree, Inkscape::XML::Node * repr);
+
+Inkscape::XML::Node * sp_xmlview_tree_node_get_repr (GtkTreeModel *model, GtkTreeIter * node);
+gboolean sp_xmlview_tree_get_repr_node (SPXMLViewTree * tree, Inkscape::XML::Node * repr, GtkTreeIter *node);
+
+
+#endif // !SEEN_SP_XMLVIEW_TREE_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 :
diff --git a/src/widgets/spw-utilities.cpp b/src/widgets/spw-utilities.cpp
new file mode 100644
index 0000000..a351223
--- /dev/null
+++ b/src/widgets/spw-utilities.cpp
@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape Widget Utilities
+ *
+ * Authors:
+ *   Bryce W. Harrington <brycehar@bryceharrington.org>
+ *   bulia byak <buliabyak@users.sf.net>
+ *
+ * Copyright (C) 2003 Bryce W. Harrington
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <cstring>
+#include <string>
+
+#include <gtkmm/box.h>
+#include <gtkmm/label.h>
+#include <gtkmm/grid.h>
+
+#include "selection.h"
+
+#include "spw-utilities.h"
+
+/**
+ * Creates a label widget with the given text, at the given col, row
+ * position in the table.
+ */
+Gtk::Label * spw_label(Gtk::Grid *table, const gchar *label_text, int col, int row, Gtk::Widget* target)
+{
+  Gtk::Label *label_widget = new Gtk::Label();
+  g_assert(label_widget != nullptr);
+  if (target != nullptr) {
+    label_widget->set_text_with_mnemonic(label_text);
+    label_widget->set_mnemonic_widget(*target);
+  } else {
+    label_widget->set_text(label_text);
+  }
+  label_widget->show();
+
+  label_widget->set_halign(Gtk::ALIGN_START);
+  label_widget->set_valign(Gtk::ALIGN_CENTER);
+  label_widget->set_margin_start(4);
+  label_widget->set_margin_end(4);
+
+  table->attach(*label_widget, col, row, 1, 1);
+
+  return label_widget;
+}
+
+/**
+ * Creates a horizontal layout manager with 4-pixel spacing between children
+ * and space for 'width' columns.
+ */
+Gtk::Box * spw_hbox(Gtk::Grid * table, int width, int col, int row)
+{
+  /* Create a new hbox with a 4-pixel spacing between children */
+  Gtk::Box *hb = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 4));
+  g_assert(hb != nullptr);
+  hb->show();
+  hb->set_hexpand();
+  hb->set_halign(Gtk::ALIGN_FILL);
+  hb->set_valign(Gtk::ALIGN_CENTER);
+  table->attach(*hb, col, row, width, 1);
+
+  return hb;
+}
+
+/**
+ * Finds the descendant of w which has the data with the given key and returns the data, or NULL if there's none.
+ */
+gpointer sp_search_by_data_recursive(GtkWidget *w, gpointer key)
+{
+    gpointer r = nullptr;
+
+    if (w && G_IS_OBJECT(w)) {
+        r = g_object_get_data(G_OBJECT(w), (gchar *) key);
+    }
+    if (r) return r;
+
+    if (GTK_IS_CONTAINER(w)) {
+            std::vector<Gtk::Widget*> children = Glib::wrap(GTK_CONTAINER(w))->get_children();
+        for (auto i:children) {
+            r = sp_search_by_data_recursive(GTK_WIDGET(i->gobj()), key);
+            if (r) return r;
+        }
+    }
+
+    return nullptr;
+}
+
+/**
+ * Returns a named descendent of parent, which has the given name, or nullptr if there's none.
+ *
+ * \param[in] parent The widget to search
+ * \param[in] name   The name of the desired child widget
+ *
+ * \return The specified child widget, or nullptr if it cannot be found
+ */
+Gtk::Widget *
+sp_search_by_name_recursive(Gtk::Widget *parent, const Glib::ustring& name)
+{
+    auto parent_bin = dynamic_cast<Gtk::Bin *>(parent);
+    auto parent_container = dynamic_cast<Gtk::Container *>(parent);
+
+    if (parent && parent->get_name() == name) {
+        return parent;
+    }
+    else if (parent_bin) {
+        auto child = parent_bin->get_child();
+        return sp_search_by_name_recursive(child, name);
+    }
+    else if (parent_container) {
+        auto children = parent_container->get_children();
+
+        for (auto child : children) {
+            auto tmp = sp_search_by_name_recursive(child, name);
+
+            if (tmp) {
+                return tmp;
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+/**
+ * Returns the descendant of w which has the given key and value pair, or NULL if there's none.
+ */
+GtkWidget *sp_search_by_value_recursive(GtkWidget *w, gchar *key, gchar *value)
+{
+    gchar *r = nullptr;
+
+    if (w && G_IS_OBJECT(w)) {
+        r = (gchar *) g_object_get_data(G_OBJECT(w), key);
+    }
+    if (r && !strcmp (r, value)) return w;
+
+    if (GTK_IS_CONTAINER(w)) {
+                std::vector<Gtk::Widget*> children = Glib::wrap(GTK_CONTAINER(w))->get_children();
+        for (auto i:children) {
+            GtkWidget *child = sp_search_by_value_recursive(GTK_WIDGET(i->gobj()), key, value);
+            if (child) return child;
+        }
+    }
+
+    return nullptr;
+}
+
+/**
+ * This function traverses a tree of widgets descending into bins and containers.
+ * It stops and returns a pointer to the first child widget for which 'eval' evaluates to true.
+ * If 'eval' never returns true then this function visits all widgets and returns nullptr.
+ *
+ * \param[in] widget The widget to start traversal from - top of the tree
+ * \param[in] eval   The callback invoked for each visited widget
+ *
+ * \return The widget for which 'eval' returned true, or nullptr otherwise.
+ * Note: it could be a starting widget too.
+ */
+Gtk::Widget* sp_traverse_widget_tree(Gtk::Widget* widget, const std::function<bool (Gtk::Widget*)>& eval) {
+    if (!widget) return nullptr;
+
+    if (eval(widget)) return widget;
+
+    if (auto bin = dynamic_cast<Gtk::Bin*>(widget)) {
+        return sp_traverse_widget_tree(bin->get_child(), eval);
+    }
+    else if (auto container = dynamic_cast<Gtk::Container*>(widget)) {
+        auto&& children = container->get_children();
+        for (auto child : children) {
+            if (auto found = sp_traverse_widget_tree(child, eval)) {
+                return found;
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+/**
+ * This function traverses a tree of widgets searching for first focusable widget.
+ *
+ * \param[in] widget The widget to start traversal from - top of the tree
+ *
+ * \return The first focusable widget or nullptr if none are focusable.
+ */
+Gtk::Widget* sp_find_focusable_widget(Gtk::Widget* widget) {
+    return sp_traverse_widget_tree(widget, [](Gtk::Widget* w) { return w->get_can_focus(); });
+}
+
+
+Glib::ustring sp_get_action_target(Gtk::Widget* widget) {
+    Glib::ustring target;
+
+    if (widget && GTK_IS_ACTIONABLE(widget->gobj())) {
+        auto variant = gtk_actionable_get_action_target_value(GTK_ACTIONABLE(widget->gobj()));
+        auto type = variant ? g_variant_get_type_string(variant) : nullptr;
+        if (type && strcmp(type, "s") == 0) {
+            target = g_variant_get_string(variant, nullptr);
+        }
+    }
+
+    return target;
+}
+/*
+  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/widgets/spw-utilities.h b/src/widgets/spw-utilities.h
new file mode 100644
index 0000000..fc37792
--- /dev/null
+++ b/src/widgets/spw-utilities.h
@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef __SPW_UTILITIES_H__
+#define __SPW_UTILITIES_H__
+
+/*
+ * Inkscape Widget Utilities
+ *
+ * Author:
+ *   Bryce W. Harrington <brycehar@bryceharrington.org>
+ *
+ * Copyright (C) 2003 Bryce Harrington
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+/* The following are helper routines for making Inkscape dialog widgets.
+   All are prefixed with spw_, short for inkscape_widget.  This is not to
+   be confused with SPWidget, an existing datatype associated with Inkscape::XML::Node/
+   SPObject, that reacts to modification.
+*/
+
+#include <glib.h>
+#include <glibmm/ustring.h>
+#include <gtk/gtk.h>
+#include <functional>
+
+namespace Gtk {
+  class Label;
+  class Grid;
+  class HBox;
+  class Widget;
+}
+
+Gtk::Label * spw_label(Gtk::Grid *table, gchar const *label_text, int col, int row, Gtk::Widget *target);
+Gtk::Box * spw_hbox(Gtk::Grid *table, int width, int col, int row);
+
+gpointer sp_search_by_data_recursive(GtkWidget *w, gpointer data);
+GtkWidget *sp_search_by_value_recursive(GtkWidget *w, gchar *key, gchar *value);
+
+Gtk::Widget * sp_search_by_name_recursive(Gtk::Widget          *parent,
+                                          const Glib::ustring&  name);
+
+Gtk::Widget* sp_traverse_widget_tree(Gtk::Widget* widget, const std::function<bool (Gtk::Widget*)>& eval);
+
+Gtk::Widget* sp_find_focusable_widget(Gtk::Widget* widget);
+
+// get string action target, if available
+Glib::ustring sp_get_action_target(Gtk::Widget* widget);
+
+#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:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/style-utils.h b/src/widgets/style-utils.h
new file mode 100644
index 0000000..1557218
--- /dev/null
+++ b/src/widgets/style-utils.h
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * Common utility functions for manipulating style.
+ *//*
+ * Authors:
+ * see git history
+ * Shlomi Fish <shlomif@cpan.org>
+ *
+ * Copyright (C) 2016 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_DIALOGS_STYLE_UTILS_H
+#define SEEN_DIALOGS_STYLE_UTILS_H
+
+#include "desktop-style.h"
+
+namespace Inkscape {
+    inline bool is_query_style_updateable(const int style) {
+        return (style == QUERY_STYLE_MULTIPLE_DIFFERENT || style == QUERY_STYLE_NOTHING);
+    }
+} // namespace Inkscape
+
+#endif // SEEN_DIALOGS_STYLE_UTILS_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/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
new file mode 100644
index 0000000..3847618
--- /dev/null
+++ b/src/widgets/toolbox.cpp
@@ -0,0 +1,641 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+/**
+ * @file
+ * Inkscape toolbar definitions and general utility functions.
+ * Each tool should have its own xxx-toolbar implementation file
+ */
+/* Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   bulia byak <buliabyak@users.sf.net>
+ *   Frank Felfe <innerspace@iname.com>
+ *   John Cliff <simarilius@yahoo.com>
+ *   David Turner <novalis@gnu.org>
+ *   Josh Andler <scislac@scislac.com>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *   Maximilian Albert <maximilian.albert@gmail.com>
+ *   Tavmjong Bah <tavmjong@free.fr>
+ *   Abhishek Sharma
+ *   Kris De Gussem <Kris.DeGussem@gmail.com>
+ *   Jabiertxo Arraiza <jabier.arraiza@marker.es>
+ *
+ * Copyright (C) 2004 David Turner
+ * Copyright (C) 2003 MenTaLguY
+ * Copyright (C) 1999-2015 authors
+ * Copyright (C) 2001-2002 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "toolbox.h"
+
+#include <gtkmm.h>
+#include <glibmm/i18n.h>
+
+#include "actions/actions-canvas-snapping.h"
+#include "actions/actions-tools.h"
+#include "io/resource.h"
+#include "ui/util.h"
+#include "ui/builder-utils.h"
+#include "ui/widget/style-swatch.h"
+#include "widgets/widget-sizes.h"
+
+#include "ui/toolbar/arc-toolbar.h"
+#include "ui/toolbar/box3d-toolbar.h"
+#include "ui/toolbar/calligraphy-toolbar.h"
+#include "ui/toolbar/connector-toolbar.h"
+#include "ui/toolbar/dropper-toolbar.h"
+#include "ui/toolbar/eraser-toolbar.h"
+#include "ui/toolbar/gradient-toolbar.h"
+#include "ui/toolbar/lpe-toolbar.h"
+#include "ui/toolbar/mesh-toolbar.h"
+#include "ui/toolbar/measure-toolbar.h"
+#include "ui/toolbar/node-toolbar.h"
+#include "ui/toolbar/booleans-toolbar.h"
+#include "ui/toolbar/rect-toolbar.h"
+#include "ui/toolbar/marker-toolbar.h"
+#include "ui/toolbar/page-toolbar.h"
+#include "ui/toolbar/paintbucket-toolbar.h"
+#include "ui/toolbar/pencil-toolbar.h"
+#include "ui/toolbar/select-toolbar.h"
+#include "ui/toolbar/spray-toolbar.h"
+#include "ui/toolbar/spiral-toolbar.h"
+#include "ui/toolbar/star-toolbar.h"
+#include "ui/toolbar/tweak-toolbar.h"
+#include "ui/toolbar/text-toolbar.h"
+#include "ui/toolbar/zoom-toolbar.h"
+
+#include "ui/tools/tool-base.h"
+
+//#define DEBUG_TEXT
+
+using Inkscape::UI::ToolboxFactory;
+using Inkscape::UI::Tools::ToolBase;
+
+using Inkscape::IO::Resource::get_filename;
+using Inkscape::IO::Resource::UIS;
+
+typedef void (*SetupFunction)(GtkWidget *toolbox, SPDesktop *desktop);
+typedef void (*UpdateFunction)(SPDesktop *desktop, ToolBase *eventcontext, GtkWidget *toolbox);
+
+enum BarId {
+    BAR_TOOL = 0,
+    BAR_AUX,
+    BAR_COMMANDS,
+    BAR_SNAP,
+};
+
+#define BAR_ID_KEY "BarIdValue"
+#define HANDLE_POS_MARK "x-inkscape-pos"
+
+int ToolboxFactory::prefToPixelSize(Glib::ustring const& path) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    int size = prefs->getIntLimited(path, 16, 16, 48);
+    return size;
+}
+
+Gtk::IconSize ToolboxFactory::prefToSize_mm(Glib::ustring const &path, int base)
+{
+    static Gtk::IconSize sizeChoices[] = { Gtk::ICON_SIZE_LARGE_TOOLBAR, Gtk::ICON_SIZE_SMALL_TOOLBAR,
+                                           Gtk::ICON_SIZE_DND, Gtk::ICON_SIZE_DIALOG };
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    int index = prefs->getIntLimited(path, base, 0, G_N_ELEMENTS(sizeChoices));
+    return sizeChoices[index];
+}
+
+static struct {
+    gchar const *type_name;
+    Glib::ustring const tool_name;
+    GtkWidget *(*create_func)(SPDesktop *desktop);
+    gchar const *swatch_tip;
+} const aux_toolboxes[] = {
+    // If you change the tool_name for Measure or Text here, change it also in desktop-widget.cpp.
+    // clang-format off
+    { "/tools/select",          "Select",       Inkscape::UI::Toolbar::SelectToolbar::create,        nullptr},
+    { "/tools/nodes",           "Node",         Inkscape::UI::Toolbar::NodeToolbar::create,          nullptr},
+    { "/tools/booleans",        "Booleans",     Inkscape::UI::Toolbar::BooleansToolbar::create,      nullptr},
+    { "/tools/marker",          "Marker",       Inkscape::UI::Toolbar::MarkerToolbar::create,        nullptr},
+    { "/tools/shapes/rect",     "Rect",         Inkscape::UI::Toolbar::RectToolbar::create,          N_("Style of new rectangles")},
+    { "/tools/shapes/arc",      "Arc",          Inkscape::UI::Toolbar::ArcToolbar::create,           N_("Style of new ellipses")},
+    { "/tools/shapes/star",     "Star",         Inkscape::UI::Toolbar::StarToolbar::create,          N_("Style of new stars")},
+    { "/tools/shapes/3dbox",    "3DBox",        Inkscape::UI::Toolbar::Box3DToolbar::create,         N_("Style of new 3D boxes")},
+    { "/tools/shapes/spiral",   "Spiral",       Inkscape::UI::Toolbar::SpiralToolbar::create,        N_("Style of new spirals")},
+    { "/tools/freehand/pencil", "Pencil",       Inkscape::UI::Toolbar::PencilToolbar::create_pencil, N_("Style of new paths created by Pencil")},
+    { "/tools/freehand/pen",    "Pen",          Inkscape::UI::Toolbar::PencilToolbar::create_pen,    N_("Style of new paths created by Pen")},
+    { "/tools/calligraphic",    "Calligraphic", Inkscape::UI::Toolbar::CalligraphyToolbar::create,   N_("Style of new calligraphic strokes")},
+    { "/tools/text",            "Text",         Inkscape::UI::Toolbar::TextToolbar::create,          nullptr},
+    { "/tools/gradient",        "Gradient",     Inkscape::UI::Toolbar::GradientToolbar::create,      nullptr},
+    { "/tools/mesh",            "Mesh",         Inkscape::UI::Toolbar::MeshToolbar::create,          nullptr},
+    { "/tools/zoom",            "Zoom",         Inkscape::UI::Toolbar::ZoomToolbar::create,          nullptr},
+    { "/tools/measure",         "Measure",      Inkscape::UI::Toolbar::MeasureToolbar::create,       nullptr},
+    { "/tools/dropper",         "Dropper",      Inkscape::UI::Toolbar::DropperToolbar::create,       nullptr},
+    { "/tools/tweak",           "Tweak",        Inkscape::UI::Toolbar::TweakToolbar::create,         N_("Color/opacity used for color tweaking")},
+    { "/tools/spray",           "Spray",        Inkscape::UI::Toolbar::SprayToolbar::create,         nullptr},
+    { "/tools/connector",       "Connector",    Inkscape::UI::Toolbar::ConnectorToolbar::create,     nullptr},
+    { "/tools/pages",           "Pages",        Inkscape::UI::Toolbar::PageToolbar::create,          nullptr},
+    { "/tools/paintbucket",     "Paintbucket",  Inkscape::UI::Toolbar::PaintbucketToolbar::create,   N_("Style of Paint Bucket fill objects")},
+    { "/tools/eraser",          "Eraser",       Inkscape::UI::Toolbar::EraserToolbar::create,        _("TBD")},
+    { "/tools/lpetool",         "LPETool",      Inkscape::UI::Toolbar::LPEToolbar::create,           _("TBD")},
+    { nullptr,                  "",             nullptr,                                             nullptr }
+    // clang-format on
+};
+
+
+static void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
+static void update_aux_toolbox(SPDesktop *desktop, ToolBase *eventcontext, GtkWidget *toolbox);
+
+static GtkWidget* toolboxNewCommon( GtkWidget* tb, BarId id, GtkPositionType /*handlePos*/ )
+{
+    g_object_set_data(G_OBJECT(tb), "desktop", nullptr);
+
+    gtk_widget_set_sensitive(tb, TRUE);
+
+    GtkWidget *hb = gtk_event_box_new(); // A simple, neutral container.
+    gtk_widget_set_name(hb, "ToolboxCommon");
+
+    gtk_container_add(GTK_CONTAINER(hb), tb);
+    gtk_widget_show(GTK_WIDGET(tb));
+
+    sigc::connection* conn = new sigc::connection;
+    g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
+
+    gpointer val = GINT_TO_POINTER(id);
+    g_object_set_data(G_OBJECT(hb), BAR_ID_KEY, val);
+
+    return hb;
+}
+
+GtkWidget *ToolboxFactory::createToolToolbox(InkscapeWindow *window)
+{
+    Gtk::Widget* toolbar = nullptr;
+
+    auto builder = Inkscape::UI::create_builder("toolbar-tool.ui");
+    builder->get_widget("tool-toolbar", toolbar);
+    if (!toolbar) {
+        std::cerr << "InkscapeWindow: Failed to load tool toolbar!" << std::endl;
+    }
+
+    _attachHandlers(builder, window);
+
+    return toolboxNewCommon( GTK_WIDGET(toolbar->gobj()), BAR_TOOL, GTK_POS_LEFT );
+}
+
+/**
+ * @brief Create a context menu for a tool button.
+ * @param tool_name The tool name (parameter to the tool-switch action)
+ * @param win The Inkscape window which will display the preferences dialog.
+ */
+Gtk::Menu *ToolboxFactory::_getContextMenu(Glib::ustring tool_name, InkscapeWindow *win)
+{
+    auto menu = new Gtk::Menu();
+    auto gio_menu = Gio::Menu::create();
+    auto action_group = Gio::SimpleActionGroup::create();
+    menu->insert_action_group("ctx", action_group);
+    action_group->add_action("open-tool-preferences", sigc::bind<Glib::ustring, InkscapeWindow *>(
+                                                          sigc::ptr_fun(&tool_preferences), tool_name, win));
+
+    auto menu_item = Gio::MenuItem::create(_("Open tool preferences"), "ctx.open-tool-preferences");
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    if (prefs->getInt("/theme/menuIcons", true)) {
+        auto _icon = Gio::Icon::create("preferences-system");
+        menu_item->set_icon(_icon);
+    }
+
+    gio_menu->append_item(menu_item);
+    menu->bind_model(gio_menu, true);
+    menu->show();
+    return menu;
+}
+
+/**
+ * @brief Attach handlers to all tool buttons, so that double-clicking on a tool
+ *        in the toolbar opens up that tool's preferences, and a right click opens a
+ *        context menu with the same functionality.
+ * @param builder The builder that contains a loaded UI structure containing RadioButton's.
+ * @param win The Inkscape window which will display the preferences dialog.
+ */
+void ToolboxFactory::_attachHandlers(Glib::RefPtr<Gtk::Builder> builder, InkscapeWindow *win)
+{
+    for (auto &object : builder->get_objects()) {
+        if (auto radio = dynamic_cast<Gtk::RadioButton *>(object.get())) {
+
+            Glib::VariantBase action_target;
+            radio->get_property("action-target", action_target);
+            if (!action_target.is_of_type(Glib::VARIANT_TYPE_STRING)) {
+                continue;
+            }
+
+            auto tool_name = Glib::ustring((gchar const *)action_target.get_data());
+
+            auto menu = _getContextMenu(tool_name, win);
+            menu->attach_to_widget(*radio);
+
+            radio->signal_button_press_event().connect([=](GdkEventButton *ev) -> bool {
+                // Open tool preferences upon double click
+                if (ev->type == GDK_2BUTTON_PRESS && ev->button == 1) {
+                    tool_preferences(tool_name, win);
+                    return true;
+                }
+                if (ev->button == 3) {
+                    menu->popup_at_pointer(reinterpret_cast<GdkEvent *>(ev));
+                }
+                return false;
+            });
+        }
+    }
+}
+
+GtkWidget *ToolboxFactory::createAuxToolbox()
+{
+    auto tb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+    gtk_widget_set_name(tb, "AuxToolbox");
+    gtk_box_set_homogeneous(GTK_BOX(tb), FALSE);
+
+    return toolboxNewCommon( tb, BAR_AUX, GTK_POS_LEFT );
+}
+
+//####################################
+//# Commands Bar
+//####################################
+
+GtkWidget *ToolboxFactory::createCommandsToolbox()
+{
+    auto tb = new Gtk::Box();
+    tb->set_name("CommandsToolbox");
+    tb->set_orientation(Gtk::ORIENTATION_VERTICAL);
+    tb->set_homogeneous(false);
+
+    Gtk::Toolbar* toolbar = nullptr;
+
+    auto builder = Inkscape::UI::create_builder("toolbar-commands.ui");
+    builder->get_widget("commands-toolbar", toolbar);
+    if (!toolbar) {
+        std::cerr << "ToolboxFactory: Failed to load commands toolbar!" << std::endl;
+    } else {
+        tb->pack_start(*toolbar, false, false);
+
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        if ( prefs->getBool("/toolbox/icononly", true) ) {
+            toolbar->set_toolbar_style( Gtk::TOOLBAR_ICONS );
+        }
+    }
+
+    return toolboxNewCommon(GTK_WIDGET(tb->gobj()), BAR_COMMANDS, GTK_POS_LEFT);
+}
+
+int show_popover(void* button) {
+    auto btn = static_cast<Gtk::MenuButton*>(button);
+    btn->get_popover()->show();
+    return false;
+}
+
+class SnapBar : public Gtk::Box {
+public:
+    SnapBar() = default;
+    ~SnapBar() override = default;
+
+    Inkscape::PrefObserver _observer;
+};
+
+GtkWidget *ToolboxFactory::createSnapToolbox()
+{
+    auto tb = new SnapBar();
+    tb->set_name("SnapToolbox");
+    tb->set_homogeneous(false);
+
+    bool simple_snap = true;
+    Gtk::Toolbar* toolbar = nullptr;
+
+    auto builder = Inkscape::UI::create_builder("toolbar-snap.ui");
+    builder->get_widget("snap-toolbar", toolbar);
+    if (!toolbar) {
+        std::cerr << "InkscapeWindow: Failed to load snap toolbar!" << std::endl;
+    } else {
+        tb->pack_start(*toolbar, false, false);
+
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        if ( prefs->getBool("/toolbox/icononly", true) ) {
+            toolbar->set_toolbar_style( Gtk::TOOLBAR_ICONS );
+        }
+        simple_snap = prefs->getBool("/toolbox/simplesnap", simple_snap);
+    }
+
+    Gtk::ToolItem* item_simple = nullptr;
+    Gtk::ToolItem* item_advanced = nullptr;
+    Gtk::MenuButton* btn_simple = nullptr;
+    Gtk::MenuButton* btn_advanced = nullptr;
+    Gtk::LinkButton* simple = nullptr;
+    Gtk::LinkButton* advanced = nullptr;
+    builder->get_widget("simple-link", simple);
+    builder->get_widget("advanced-link", advanced);
+    builder->get_widget("tool-item-advanced", item_advanced);
+    builder->get_widget("tool-item-simple", item_simple);
+    builder->get_widget("btn-simple", btn_simple);
+    builder->get_widget("btn-advanced", btn_advanced);
+    if (simple && advanced && item_simple && item_advanced && btn_simple && btn_advanced) {
+        // keep only one popup button visible
+        if (simple_snap) {
+            item_simple->show();
+            item_advanced->hide();
+        }
+        else {
+            item_advanced->show();
+            item_simple->hide();
+        }
+
+        // Watch snap bar preferences;
+        Inkscape::Preferences* prefs = Inkscape::Preferences::get();
+        tb->_observer = prefs->createObserver(ToolboxFactory::snap_bar_simple, [=](const Preferences::Entry& entry) {
+            if (entry.getBool(true)) {
+                item_advanced->hide();
+                item_simple->show();
+                // adjust snapping options when transitioning to simple scheme, since most are hidden
+                transition_to_simple_snapping();
+            }
+            else {
+                item_simple->hide();
+                item_advanced->show();
+            }
+        });
+
+        // switch to simple mode
+        simple->signal_activate_link().connect([=](){
+            g_timeout_add(250, &show_popover, btn_simple);
+            Inkscape::Preferences::get()->setBool(ToolboxFactory::snap_bar_simple, true);
+            return true;
+        }, false);
+
+        // switch to advanced mode
+        advanced->signal_activate_link().connect([=](){
+            g_timeout_add(250, &show_popover, btn_advanced);
+            Inkscape::Preferences::get()->setBool(ToolboxFactory::snap_bar_simple, false);
+            return true;
+        }, false);
+    }
+
+    return toolboxNewCommon(GTK_WIDGET(tb->gobj()), BAR_SNAP, GTK_POS_LEFT);
+}
+
+void ToolboxFactory::setToolboxDesktop(GtkWidget *toolbox, SPDesktop *desktop)
+{
+    sigc::connection *conn = static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
+                                                                              "event_context_connection"));
+
+    BarId id = static_cast<BarId>( GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY)) );
+
+    SetupFunction setup_func = nullptr;
+    UpdateFunction update_func = nullptr;
+
+    switch (id) {
+        case BAR_TOOL:
+            setup_func = nullptr; // setup_tool_toolbox;
+            update_func = nullptr; // update_tool_toolbox;
+            break;
+
+        case BAR_AUX:
+            toolbox = gtk_bin_get_child(GTK_BIN(toolbox));
+            setup_func = setup_aux_toolbox;
+            update_func = update_aux_toolbox;
+            break;
+
+        case BAR_COMMANDS:
+            setup_func = nullptr; // setup_commands_toolbox;
+            update_func = nullptr; // update_commands_toolbox;
+            break;
+
+        case BAR_SNAP:
+            setup_func = nullptr;
+            update_func = nullptr;
+            break;
+        default:
+            g_warning("Unexpected toolbox id encountered.");
+    }
+
+    gpointer ptr = g_object_get_data(G_OBJECT(toolbox), "desktop");
+    SPDesktop *old_desktop = static_cast<SPDesktop*>(ptr);
+
+    if (old_desktop) {
+        std::vector<Gtk::Widget*> children = Glib::wrap(GTK_CONTAINER(toolbox))->get_children();
+        for ( auto i:children ) {
+            gtk_container_remove( GTK_CONTAINER(toolbox), i->gobj() );
+        }
+    }
+
+    g_object_set_data(G_OBJECT(toolbox), "desktop", (gpointer)desktop);
+
+    if (desktop && setup_func && update_func) {
+        gtk_widget_set_sensitive(toolbox, TRUE);
+        setup_func(toolbox, desktop);
+        update_func(desktop, desktop->event_context, toolbox);
+        *conn = desktop->connectEventContextChanged(sigc::bind (sigc::ptr_fun(update_func), toolbox));
+    } else {
+        gtk_widget_set_sensitive(toolbox, TRUE);
+    }
+
+} // end of sp_toolbox_set_desktop()
+
+
+#define noDUMP_DETAILS 1
+
+void ToolboxFactory::setOrientation(GtkWidget* toolbox, GtkOrientation orientation)
+{
+#if DUMP_DETAILS
+    g_message("Set orientation for %p to be %d", toolbox, orientation);
+    GType type = G_OBJECT_TYPE(toolbox);
+    g_message("        [%s]", g_type_name(type));
+    g_message("             %p", g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY));
+#endif
+
+    GtkPositionType pos = (orientation == GTK_ORIENTATION_HORIZONTAL) ? GTK_POS_LEFT : GTK_POS_TOP;
+
+    if (GTK_IS_BIN(toolbox)) {
+#if DUMP_DETAILS
+        g_message("            is a BIN");
+#endif // DUMP_DETAILS
+        GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
+        if (child) {
+#if DUMP_DETAILS
+            GType type2 = G_OBJECT_TYPE(child);
+            g_message("            child    [%s]", g_type_name(type2));
+#endif // DUMP_DETAILS
+
+            if (GTK_IS_BOX(child)) {
+#if DUMP_DETAILS
+                g_message("                is a BOX");
+#endif // DUMP_DETAILS
+
+                std::vector<Gtk::Widget*> children = Glib::wrap(GTK_CONTAINER(child))->get_children();
+                if (!children.empty()) {
+                    for (auto curr:children) {
+                        GtkWidget* child2 = curr->gobj();
+#if DUMP_DETAILS
+                        GType type3 = G_OBJECT_TYPE(child2);
+                        g_message("                child2   [%s]", g_type_name(type3));
+#endif // DUMP_DETAILS
+
+                        if (GTK_IS_CONTAINER(child2)) {
+                            std::vector<Gtk::Widget*> children2 = Glib::wrap(GTK_CONTAINER(child2))->get_children();
+                            if (!children2.empty()) {
+                                for (auto curr2:children2) {
+                                    GtkWidget* child3 = curr2->gobj();
+#if DUMP_DETAILS
+                                    GType type4 = G_OBJECT_TYPE(child3);
+                                    g_message("                    child3   [%s]", g_type_name(type4));
+#endif // DUMP_DETAILS
+                                    if (GTK_IS_TOOLBAR(child3)) {
+                                        GtkToolbar* childBar = GTK_TOOLBAR(child3);
+                                        gtk_orientable_set_orientation(GTK_ORIENTABLE(childBar), orientation);
+                                    }
+                                }
+                            }
+                        }
+
+
+                        if (GTK_IS_TOOLBAR(child2)) {
+                            GtkToolbar* childBar = GTK_TOOLBAR(child2);
+                            gtk_orientable_set_orientation(GTK_ORIENTABLE(childBar), orientation);
+                        } else {
+                            g_message("need to add dynamic switch");
+                        }
+                    }
+                } else {
+                    // The call is being made before the toolbox proper has been setup.
+                    g_object_set_data(G_OBJECT(toolbox), HANDLE_POS_MARK, GINT_TO_POINTER(pos));
+                }
+            } else if (GTK_IS_TOOLBAR(child)) {
+                GtkToolbar* toolbar = GTK_TOOLBAR(child);
+                gtk_orientable_set_orientation( GTK_ORIENTABLE(toolbar), orientation );
+            }
+        }
+    }
+}
+
+/**
+ * \brief Generate the auxiliary toolbox
+ *
+ * \details This is the one that appears below the main menu, and contains
+ *          tool-specific toolbars.  Each toolbar is created here, using
+ *          its "create" method.
+ *
+ *          The actual method used for each toolbar is specified in the
+ *          "aux_toolboxes" array, defined above.
+ */
+void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    // Loop through all the toolboxes and create them using either
+    // their "create" methods.
+    for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
+        if (aux_toolboxes[i].create_func) {
+            GtkWidget *sub_toolbox = aux_toolboxes[i].create_func(desktop);
+            // center items vertically/horizontally to prevent stretching;
+            // all buttons will look uniform across toolbars if their original size is preserved
+            if (auto* tb = dynamic_cast<Gtk::Container*>(Glib::wrap(sub_toolbox))) {
+                for (auto&& item : tb->get_children()) {
+                    if (dynamic_cast<Gtk::Button*>(item) ||
+                        dynamic_cast<Gtk::SpinButton*>(item) ||
+                        dynamic_cast<Gtk::ToolButton*>(item)) {
+                        item->set_valign(Gtk::ALIGN_CENTER);
+                        item->set_halign(Gtk::ALIGN_CENTER);
+                    }
+                }
+            }
+            gtk_widget_set_name( sub_toolbox, "SubToolBox" );
+
+            auto holder = gtk_grid_new();
+            gtk_grid_attach(GTK_GRID(holder), sub_toolbox, 0, 0, 1, 1);
+
+            // This part is just for styling
+            if ( prefs->getBool( "/toolbox/icononly", true) ) {
+                gtk_toolbar_set_style( GTK_TOOLBAR(sub_toolbox), GTK_TOOLBAR_ICONS );
+            }
+
+            int pixel_size = ToolboxFactory::prefToPixelSize(ToolboxFactory::ctrlbars_icon_size);
+            Inkscape::UI::set_icon_sizes(sub_toolbox, pixel_size);
+            gtk_widget_set_hexpand(sub_toolbox, TRUE);
+
+            // Add a swatch widget if swatch tooltip is defined.
+            if ( aux_toolboxes[i].swatch_tip) {
+                auto swatch = new Inkscape::UI::Widget::StyleSwatch( nullptr, _(aux_toolboxes[i].swatch_tip) );
+                swatch->setDesktop( desktop );
+                swatch->setToolName(aux_toolboxes[i].tool_name);
+                // swatch->setClickVerb( aux_toolboxes[i].swatch_verb_id );
+                swatch->setWatchedTool( aux_toolboxes[i].type_name, true );
+                swatch->set_margin_start(AUX_BETWEEN_BUTTON_GROUPS);
+                swatch->set_margin_end(AUX_BETWEEN_BUTTON_GROUPS);
+                swatch->set_margin_top(AUX_SPACING);
+                swatch->set_margin_bottom(AUX_SPACING);
+
+                auto swatch_ = GTK_WIDGET( swatch->gobj() );
+                gtk_grid_attach( GTK_GRID(holder), swatch_, 1, 0, 1, 1);
+            }
+
+            // Add the new toolbar into the toolbox (i.e., make it the visible toolbar)
+            // and also store a pointer to it inside the toolbox.  This allows the
+            // active toolbar to be changed.
+            gtk_container_add(GTK_CONTAINER(toolbox), holder);
+            Glib::ustring ui_name = aux_toolboxes[i].tool_name + "Toolbar";  // If you change "Toolbar" here, change it also in desktop-widget.cpp.
+            gtk_widget_set_name( holder, ui_name.c_str() );
+
+            // TODO: We could make the toolbox a custom subclass of GtkEventBox
+            //       so that we can store a list of toolbars, rather than using
+            //       GObject data
+            g_object_set_data(G_OBJECT(toolbox), aux_toolboxes[i].tool_name.c_str(), holder);
+            gtk_widget_show(sub_toolbox);
+            gtk_widget_show(holder);
+        } else if (aux_toolboxes[i].swatch_tip) {
+            g_warning("Could not create toolbox %s", aux_toolboxes[i].tool_name.c_str());
+        }
+    }
+}
+
+void update_aux_toolbox(SPDesktop * /*desktop*/, ToolBase *eventcontext, GtkWidget *toolbox)
+{
+    for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
+        GtkWidget *sub_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), aux_toolboxes[i].tool_name.c_str()));
+        if (eventcontext && eventcontext->getPrefsPath() == aux_toolboxes[i].type_name) {
+            gtk_widget_show_now(sub_toolbox);
+            g_object_set_data(G_OBJECT(toolbox), "shows", sub_toolbox);
+        } else {
+            gtk_widget_hide(sub_toolbox);
+        }
+        //FIX issue #Inkscape686
+        GtkAllocation allocation;
+        gtk_widget_get_allocation(sub_toolbox, &allocation);
+        gtk_widget_size_allocate(sub_toolbox, &allocation);
+    }
+    //FIX issue #Inkscape125
+    GtkAllocation allocation;
+    gtk_widget_get_allocation(toolbox, &allocation);
+    gtk_widget_size_allocate(toolbox, &allocation);  
+}
+
+void ToolboxFactory::showAuxToolbox(GtkWidget *toolbox_toplevel)
+{
+    gtk_widget_show(toolbox_toplevel);
+    GtkWidget *toolbox = gtk_bin_get_child(GTK_BIN(toolbox_toplevel));
+
+    GtkWidget *shown_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), "shows"));
+    if (!shown_toolbox) {
+        return;
+    }
+    gtk_widget_show(toolbox);
+}
+
+Glib::ustring ToolboxFactory::get_tool_visible_buttons_path(const Glib::ustring& button_action_name) {
+    return Glib::ustring(ToolboxFactory::tools_visible_buttons) + "/show" + button_action_name;
+}
+
+/*
+  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/widgets/toolbox.h b/src/widgets/toolbox.h
new file mode 100644
index 0000000..c95250b
--- /dev/null
+++ b/src/widgets/toolbox.h
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_TOOLBOX_H
+#define SEEN_TOOLBOX_H
+
+/*
+ * Authors:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   Frank Felfe <innerspace@iname.com>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 1999-2002 Authors
+ * Copyright (C) 2001-2002 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/ustring.h>
+#include <gtk/gtk.h>
+#include <gtkmm.h>
+#include <gtkmm/builder.h>
+#include <gtkmm/enums.h>
+
+#include "preferences.h"
+
+class InkscapeWindow;
+class SPDesktop;
+
+namespace Inkscape {
+namespace UI {
+
+/**
+ * Main toolbox source.
+ */
+class ToolboxFactory
+{
+public:
+    static void setToolboxDesktop(GtkWidget *toolbox, SPDesktop *desktop);
+    static void setOrientation(GtkWidget* toolbox, GtkOrientation orientation);
+    static void showAuxToolbox(GtkWidget* toolbox);
+
+    static GtkWidget *createToolToolbox(InkscapeWindow *window);
+    static GtkWidget *createAuxToolbox();
+    static GtkWidget *createCommandsToolbox();
+    static GtkWidget *createSnapToolbox();
+
+    static int prefToPixelSize(Glib::ustring const& path);
+    static Gtk::IconSize prefToSize_mm(Glib::ustring const &path, int base = 0);
+
+    ToolboxFactory() = delete;
+
+    static constexpr const char* tools_icon_size = "/toolbox/tools/iconsize";
+    static constexpr const char* tools_visible_buttons = "/toolbox/tools/buttons"; 
+    static constexpr const char* ctrlbars_icon_size = "/toolbox/controlbars/iconsize";
+    static constexpr const char* snap_bar_simple = "/toolbox/simplesnap";
+    static constexpr const int min_pixel_size = 16;
+    static constexpr const int max_pixel_size = 48;
+    static Glib::ustring get_tool_visible_buttons_path(const Glib::ustring& button_action_name);
+
+private:
+    static Gtk::Menu *_getContextMenu(Glib::ustring tool_name, InkscapeWindow *window);
+    static void _attachHandlers(Glib::RefPtr<Gtk::Builder> builder, InkscapeWindow *window);
+};
+
+
+
+} // namespace UI
+} // namespace Inkscape
+
+#endif /* !SEEN_TOOLBOX_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/widgets/widget-sizes.h b/src/widgets/widget-sizes.h
new file mode 100644
index 0000000..e70b071
--- /dev/null
+++ b/src/widgets/widget-sizes.h
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors: see git history
+ *
+ * Copyright (C) 2016 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+// #define TOOL_BUTTON_SIZE 28
+
+// GTK uses 24 for icon sizes by default.  Spacing adjust to keep the
+// toolbar the same as other GTK applications.  If we want that, use
+// these defines instead:
+//#define AUX_BUTTON_SIZE 24
+//#define AUX_SPACING 2
+
+// #define AUX_BUTTON_SIZE 20
+#define AUX_SPACING 3
+
+#define AUX_BETWEEN_BUTTON_GROUPS 7
+
+#define SPIN_STEP 0.1
+#define SPIN_PAGE_STEP 5.0
+
+#define STATUS_ZOOM_WIDTH 57
+#define STATUS_ROTATION_WIDTH 57
+
+/*
+  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 :