Rewrite main menu bar code:

  Convert to GTKMM.
  General cleanup.
  Move to dedicated files.

6 files changed, 590 insertions, 624 deletions

diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt
index 7125a4aa2..46978d87a 100644
--- a/src/ui/CMakeLists.txt
+++ b/src/ui/CMakeLists.txt
@@ -21,6 +21,8 @@ set(ui_SRC
 
 	cache/svg_preview_cache.cpp
 
+        desktop/menubar.cpp
+
 	tool/control-point-selection.cpp
 	tool/control-point.cpp
 	tool/curve-drag-point.cpp
@@ -239,6 +241,8 @@ set(ui_SRC
 
 	cache/svg_preview_cache.h
 
+        desktop/menubar.cpp
+
 	dialog/aboutbox.h
 	dialog/align-and-distribute.h
 	dialog/arrange-tab.h
diff --git a/src/ui/desktop/README b/src/ui/desktop/README
new file mode 100644
index 000000000..af0799694
--- /dev/null
+++ b/src/ui/desktop/README
@@ -0,0 +1,27 @@
+
+
+This directory contains code related to the Inkscape desktop, that is
+code that is directly used by the InkscapeWindow class and in linking
+the desktop to the canvas. It should not contain basic widgets,
+dialogs, toolbars, etc.
+
+To do:
+
+* widgets/desktop-widget.h/cpp should disappear with code ending up in either
+  InkscapeWindow.h/cpp or desktop.h/cpp (or in new files).
+
+* ui/view/view-widget.h/cpp should disappear ('view' should be member of window)
+
+* desktop.h/cpp should only contain code that links the desktop to the canvas.
+
+* Convert GUI to use actions where possible.
+
+* Future Structure:
+    Main menu bar   (menubar.h/.cpp)
+    Tool bar
+    Multipaned widget containing
+        Dialogs
+        Tools
+        Canvas
+    Palatte (maybe turn into dialog).
+    Status bar
diff --git a/src/ui/desktop/menubar.cpp b/src/ui/desktop/menubar.cpp
new file mode 100644
index 000000000..38d2a5ad3
--- /dev/null
+++ b/src/ui/desktop/menubar.cpp
@@ -0,0 +1,513 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Desktop main menu bar code.
+ */
+/*
+ * Authors:
+ *   Tavmjong Bah       <tavmjong@free.fr>
+ *   Alex Valavanis     <valavanisalex@gmail.com>
+ *   Patrick Storz      <eduard.braun2@gmx.de>
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ *   Kris De Gussem     <Kris.DeGussem@gmail.com>
+ *
+ * Copyright (C) 2018 Authors
+ *
+ * The contents of this file may be used under the GNU General Public License Version 2 or later.
+ * Read the file 'COPYING' for more information.
+ *
+ */
+
+#include <gtkmm.h>
+#include <glibmm/i18n.h>
+
+#include <iostream>
+
+#include "inkscape.h"
+#include "file.h"  // sp_file_open
+#include "message-context.h"
+#include "shortcuts.h"
+
+#include "helper/action.h"
+#include "helper/action-context.h"
+
+#include "object/sp-namedview.h"
+
+#include "ui/contextmenu.h" // Shift to make room for icons
+#include "ui/icon-loader.h"
+#include "ui/view/view.h"
+#include "ui/uxmanager.h"   // To Do: Convert to actions
+
+// ================= Common ====================
+
+// Sets tip
+static void
+select_action(SPAction *action)
+{
+    sp_action_get_view(action)->tipsMessageContext()->set(Inkscape::NORMAL_MESSAGE, action->tip);
+}
+
+// Clears tip
+static void
+deselect_action(SPAction *action)
+{
+    sp_action_get_view(action)->tipsMessageContext()->clear();
+}
+
+// Trigger action
+static void
+item_activate(Gtk::MenuItem* menuitem, SPAction* action)
+{
+    sp_action_perform(action, nullptr);
+}
+
+// Change label name (used in the Undo/Redo menu items).
+static void
+set_name(Glib::ustring const &name, Gtk::MenuItem* menuitem)
+{
+    if (menuitem) {
+        Gtk::Widget* widget = menuitem->get_child();
+
+        // Label is either child of menuitem
+        Gtk::Label* label = dynamic_cast<Gtk::Label*>(widget);
+
+        // Or wrapped inside a box which is a child of menuitem (if with icon).
+        if (!label) {
+            Gtk::Box* box = dynamic_cast<Gtk::Box*>(widget);
+            if (box) {
+                std::vector<Gtk::Widget*> children = box->get_children();
+                for (auto child: children) {
+                    label = dynamic_cast<Gtk::Label*>(child);
+                    if (label) break;
+                }
+            }
+        }
+
+        if (label) {
+            label->set_markup_with_mnemonic(name);
+        } else {
+            std::cerr << "set_name: could not find label!" << std::endl;
+        }           
+    }
+}
+
+/* Install CSS to shift icons into the space reserved for toggles (i.e. check and radio items).
+ *
+ * TODO: This code already exists as a C++ version in the class ContextMenu so we can simply wrap
+ *       it here. In future ContextMenu and the (to be created) class for the menu bar should then
+ *       be derived from one common base class.
+ *
+ * TODO: This code is called everytime a menu is opened. We can certainly find a way to call it once.
+ */
+static void
+shift_icons(Gtk::Menu* menu)
+{
+    ContextMenu *contextmenu = static_cast<ContextMenu*>(menu);
+    contextmenu->ShiftIcons();
+}
+
+// ================= MenuItem ====================
+
+Gtk::MenuItem*
+build_menu_item_from_verb(SPAction* action,
+                          bool show_icon,
+                          bool radio = false,
+                          Gtk::RadioMenuItem::Group *group = nullptr)
+{
+    Gtk::MenuItem* menuitem = nullptr;
+
+    if (radio) {
+        menuitem = Gtk::manage(new Gtk::RadioMenuItem(*group));
+    } else {
+        menuitem = Gtk::manage(new Gtk::MenuItem());
+    }
+
+    Gtk::AccelLabel* label = Gtk::manage(new Gtk::AccelLabel(action->name, true));
+    label->set_alignment(0.0, 0.5);
+    label->set_accel_widget(*menuitem);
+    sp_shortcut_add_accelerator((GtkWidget*)menuitem->gobj(), sp_shortcut_get_primary(action->verb));
+
+    // If there is an image associated with the action, we can add it as an icon for the menu item.
+    if (show_icon && action->image) {
+        menuitem->set_name("ImageMenuItem");  // custom name to identify our "ImageMenuItems"
+        Gtk::Image* image = Gtk::manage(sp_get_icon_image(action->image, Gtk::ICON_SIZE_MENU));
+
+        // Create a box to hold icon and label as Gtk::MenuItem derives from GtkBin and can
+        // only hold one child
+        Gtk::Box *box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
+        box->pack_start(*image, false, false, 0);
+        box->pack_start(*label, true,  true,  0);
+        menuitem->add(*box);
+    } else {
+        menuitem->add(*label);
+    }
+
+    menuitem->signal_activate().connect(
+        sigc::bind<Gtk::MenuItem*, SPAction*>(sigc::ptr_fun(&item_activate), menuitem, action));
+    menuitem->signal_select().connect(  sigc::bind<SPAction*>(sigc::ptr_fun(&select_action),   action));
+    menuitem->signal_deselect().connect(sigc::bind<SPAction*>(sigc::ptr_fun(&deselect_action), action));
+
+    action->signal_set_sensitive.connect(
+        sigc::bind<0>(sigc::ptr_fun(&gtk_widget_set_sensitive), (GtkWidget*)menuitem->gobj()));
+    action->signal_set_name.connect(
+        sigc::bind<Gtk::MenuItem*>(sigc::ptr_fun(&set_name), menuitem));
+
+    return menuitem;
+}
+
+// =============== CheckMenuItem ==================
+
+static bool
+getStateFromPref(SPDesktop* dt, Glib::ustring item)
+{
+    Glib::ustring pref_path;
+
+    if (dt->is_focusMode()) {
+        pref_path = "/focus/";
+    } else if (dt->is_fullscreen()) {
+        pref_path = "/fullscreen/";
+    } else {
+        pref_path = "/window/";
+    }
+
+    pref_path += item;
+    pref_path += "/state";
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    return prefs->getBool(pref_path, false);
+}
+
+// I wonder if this can be done without hard coding names.
+static void
+checkitem_update(Gtk::CheckMenuItem* menuitem, SPAction* action)
+{
+    bool active = false;
+    if (action && action->id) {
+        Glib::ustring id = action->id;
+        SPDesktop* dt = static_cast<SPDesktop*>(sp_action_get_view(action));
+
+        if (id == "ToggleGrid") {
+            active = dt->gridsEnabled();
+
+        } else if (id == "EditGuidesToggleLock") {
+            active = dt->namedview->lockguides;
+
+        } else if (id == "ToggleGuides") {
+            active = dt->namedview->getGuides();
+
+        } else if (id == "ViewCmsToggle") {
+            active = dt->colorProfAdjustEnabled();
+
+        } else if (id == "ViewSplitModeToggle") {
+            active = dt->splitMode();
+
+        } else if (id == "ViewXRayToggle") {
+            active = dt->xrayMode();
+
+        } else if (id == "ToggleCommandsToolbar") {
+            active = getStateFromPref(dt, "commands");
+
+        } else if (id == "ToggleSnapToolbar") {
+            active = getStateFromPref(dt, "snaptoolbox");
+
+        } else if (id == "ToggleToolToolbar") {
+            active = getStateFromPref(dt, "toppanel");
+
+        } else if (id == "ToggleToolbox") {
+            active = getStateFromPref(dt, "toolbox");
+
+        } else if (id == "ToggleRulers") {
+            active = getStateFromPref(dt, "rulers");
+
+        } else if (id == "ToggleScrollbars") {
+            active = getStateFromPref(dt, "scrollbars");
+
+        } else if (id == "TogglePalette") {
+            active = getStateFromPref(dt, "panels");  // Rename?
+
+        } else if (id == "ToggleStatusbar") {
+            active = getStateFromPref(dt, "statusbar");
+
+        } else {
+            std::cerr << "checkitem_update: unhandled item: " << id << std::endl;
+        }
+
+        menuitem->set_active(active);
+    } else {
+        std::cerr << "checkitem_update: unknown action" << std::endl;
+    }      
+}
+
+static Gtk::CheckMenuItem*
+build_menu_check_item_from_verb(SPAction* action)
+{
+    // This does not work for some reason!
+    // Gtk::CheckMenuItem* menuitem = Gtk::manage(new Gtk::CheckMenuItem(action->name, true));
+    // sp_shortcut_add_accelerator(GTK_WIDGET(menuitem->gobj()), sp_shortcut_get_primary(action->verb));
+
+    GtkWidget *item = gtk_check_menu_item_new_with_mnemonic(action->name);
+    sp_shortcut_add_accelerator(item, sp_shortcut_get_primary(action->verb));
+    Gtk::CheckMenuItem* menuitem = Gtk::manage(Glib::wrap(GTK_CHECK_MENU_ITEM(item)));
+
+    // Set initial state before connecting signals.
+    checkitem_update(menuitem, action);
+
+    menuitem->signal_toggled().connect(
+      sigc::bind<Gtk::CheckMenuItem*, SPAction*>(sigc::ptr_fun(&item_activate), menuitem, action)); 
+    menuitem->signal_select().connect(  sigc::bind<SPAction*>(sigc::ptr_fun(&select_action),   action));
+    menuitem->signal_deselect().connect(sigc::bind<SPAction*>(sigc::ptr_fun(&deselect_action), action));
+
+    return menuitem;
+}
+
+// ================= Tasks Submenu ==============
+static void
+task_activated(SPDesktop* dt, int number)
+{
+    Inkscape::UI::UXManager::getInstance()->setTask(dt, number);
+}
+
+// Sets tip
+static void
+select_task(SPDesktop* dt, Glib::ustring tip)
+{
+    dt->tipsMessageContext()->set(Inkscape::NORMAL_MESSAGE, tip.c_str());
+}
+
+// Clears tip
+static void
+deselect_task(SPDesktop* dt)
+{
+    dt->tipsMessageContext()->clear();
+}
+
+static void
+add_tasks(Gtk::MenuShell* menu, SPDesktop* dt)
+{
+    const Glib::ustring data[3][2] = {
+        { C_("Interface setup", "Default"), _("Default interface setup")   },
+        { C_("Interface setup", "Custom"),  _("Setup for custom task")     },
+        { C_("Interface setup", "Wide"),    _("Setup for widescreen work") }
+    };
+
+    int active = Inkscape::UI::UXManager::getInstance()->getDefaultTask(dt);
+
+    Gtk::RadioMenuItem::Group group;
+
+    for (unsigned int i = 0; i < 3; ++i) {
+
+        Gtk::RadioMenuItem* menuitem = Gtk::manage(new Gtk::RadioMenuItem(group, data[i][0]));
+        if (menuitem) {
+            if (active == i) {
+                menuitem->set_active();
+            }
+
+            menuitem->signal_toggled().connect(
+                sigc::bind<SPDesktop*, int>(sigc::ptr_fun(&task_activated), dt, i)); 
+            menuitem->signal_select().connect(
+                sigc::bind<SPDesktop*, Glib::ustring>(sigc::ptr_fun(&select_task),  dt, data[i][1]));
+            menuitem->signal_deselect().connect(
+                sigc::bind<SPDesktop*>(sigc::ptr_fun(&deselect_task),dt));
+
+            menu->append(*menuitem);
+        }
+    }
+}
+
+
+static void
+sp_recent_open(Gtk::RecentChooser* recentchooser)
+{
+    Glib::ustring uri = recentchooser->get_current_uri();
+
+    Glib::RefPtr<Gio::File> file = Gio::File::create_for_uri(uri);
+
+    // To do: change sp_file_open to use Gio::File.
+    // To do: get rid of sp_file_open
+    sp_file_open(file->get_parse_name(), nullptr);
+}
+
+// =================== Main Menu ================
+// Recursively build menu and submenus.
+void
+build_menu(Gtk::MenuShell* menu, Inkscape::XML::Node* xml, Inkscape::UI::View::View* view)
+{
+    if (menu == nullptr) {
+        std::cerr << "build_menu: menu is nullptr" << std::endl;
+        return;
+    }
+
+    if (xml == nullptr) {
+        std::cerr << "build_menu: xml is nullptr" << std::endl;
+        return;
+    }
+
+    // Do we want icons????
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    int show_icon_pref = prefs->getInt("/theme/menuIcons", 0);
+    static bool show_icon = false;
+    if (show_icon_pref ==  1) {
+        show_icon = true;
+    } else if ( show_icon_pref == -1) {
+        show_icon = false;
+    }
+
+    Gtk::RadioMenuItem::Group group;
+
+    for (auto menu_ptr = xml; menu_ptr != nullptr; menu_ptr = menu_ptr->next()) {
+
+        if (show_icon_pref == 0) {
+            // We set according to file, value is inherited into sub-menus.
+            const char *str = menu_ptr->attribute("show-icons");
+            if (str) {
+                Glib::ustring ustr = str;
+                if (ustr == "true") {
+                    show_icon = true;
+                } else if (ustr == "false") {
+                    show_icon = false;
+                } else {
+                    std::cerr << "build_menu: invalid value for 'show-icon' (use 'true' or 'false')."
+                              << ustr << std::endl;
+                }
+            }
+        }
+
+        if (menu_ptr->name()) {
+            Glib::ustring name = menu_ptr->name();
+
+            if (name == "inkscape") {
+                build_menu(menu, menu_ptr->firstChild(), view);
+                continue;
+            }
+
+            if (name == "submenu") {
+                Gtk::MenuItem* menuitem = nullptr;
+                if (menu_ptr->attribute("_name") != nullptr) {
+                    menuitem = Gtk::manage(new Gtk::MenuItem(_(menu_ptr->attribute("_name")), true));
+                } else {
+                    menuitem = Gtk::manage(new Gtk::MenuItem(  menu_ptr->attribute("name"),   true));
+                }
+                Gtk::Menu* submenu = Gtk::manage(new Gtk::Menu());
+                build_menu(submenu, menu_ptr->firstChild(), view);
+                menuitem->set_submenu(*submenu);
+                menu->append(*menuitem);
+
+                submenu->signal_map().connect(
+                    sigc::bind<Gtk::Menu*>(sigc::ptr_fun(&shift_icons), submenu));
+
+                continue;
+            }
+
+            if (name == "verb") {
+                if (menu_ptr->attribute("verb-id") != nullptr) {
+                    Glib::ustring verb_name = menu_ptr->attribute("verb-id");
+
+                    Inkscape::Verb *verb = Inkscape::Verb::getbyid(verb_name.c_str());
+                    if (verb != nullptr && verb->get_code() != SP_VERB_NONE) {
+
+                        SPAction* action = verb->get_action(Inkscape::ActionContext(view));
+
+                        if (menu_ptr->attribute("check") != nullptr) {
+
+                            Gtk::CheckMenuItem* menuitem = build_menu_check_item_from_verb(action);
+                            if (menuitem) {
+                                menu->append(*menuitem);
+                            }
+
+                        } else if (menu_ptr->attribute("radio") != nullptr) {
+
+                            Gtk::MenuItem* menuitem = build_menu_item_from_verb(action, show_icon, true, &group);
+                            if (menuitem) {
+                                if (menu_ptr->attribute("default") != nullptr) {
+                                    auto radiomenuitem = dynamic_cast<Gtk::RadioMenuItem*>(menuitem);
+                                    if (radiomenuitem) {
+                                        radiomenuitem->set_active(true);
+                                    }
+                                }
+                                menu->append(*menuitem);
+                            }
+
+                        } else {
+
+                            Gtk::MenuItem* menuitem = build_menu_item_from_verb(action, show_icon);
+                            if (menuitem) {
+                                menu->append(*menuitem);
+                            }
+                        }
+                    } else {
+                        std::cerr << "build_menu: no verb with id: " << verb_name << std::endl;
+                    }
+                }
+                continue;
+            }
+
+            // This is used only for wide-screen vs non-wide-screen displays.
+            // The code should be rewritten to use actions like everything else here.
+            if (name == "task-checkboxes") {
+                add_tasks(menu, static_cast<SPDesktop*>(view));
+                continue;
+            }
+
+            if (name == "recent-file-list") {
+
+                // Filter recent files to those already opened in Inkscape.
+                Glib::RefPtr<Gtk::RecentFilter> recentfilter = Gtk::RecentFilter::create();
+                recentfilter->add_application(g_get_prgname());
+
+                Gtk::RecentChooserMenu* recentchoosermenu = Gtk::manage(new Gtk::RecentChooserMenu());
+                int max = Inkscape::Preferences::get()->getInt("/options/maxrecentdocuments/value");
+                recentchoosermenu->set_limit(max);
+                recentchoosermenu->set_sort_type(Gtk::RECENT_SORT_MRU); // Sort most recent first.
+                recentchoosermenu->set_show_tips(true);
+                recentchoosermenu->set_show_not_found(false);
+                recentchoosermenu->add_filter(recentfilter);
+                recentchoosermenu->signal_item_activated().connect(
+                    sigc::bind<Gtk::RecentChooserMenu*>(sigc::ptr_fun(&sp_recent_open), recentchoosermenu));
+
+                Gtk::MenuItem* menuitem = Gtk::manage(new Gtk::MenuItem(_("Open _Recent")));
+                menuitem->set_submenu(*recentchoosermenu);
+                menu->append(*menuitem);
+                continue;
+            }
+
+            if (name == "separator") {
+                Gtk::MenuItem* menuitem = Gtk::manage(new Gtk::SeparatorMenuItem());
+                menu->append(*menuitem);
+                continue;
+            }
+
+            // Comments and items handled elsewhere.
+            if (name == "comment"      ||
+                name == "filters-list" ||
+                name == "effects-list" ) {
+                continue;
+            }
+
+            std::cerr << "build_menu: unhandled option: " << name << std::endl;
+
+        } else {
+            std::cerr << "build_menu: xml node has no name!" << std::endl;
+        }
+    }
+
+}
+
+Gtk::MenuBar*
+build_menubar(Inkscape::UI::View::View* view)
+{
+    Gtk::MenuBar* menubar = Gtk::manage(new Gtk::MenuBar());
+    build_menu(menubar, INKSCAPE.get_menus()->parent(), view);
+    return menubar;
+}
+
+
+/*
+  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/ui/desktop/menubar.h b/src/ui/desktop/menubar.h
new file mode 100644
index 000000000..cf50c7f88
--- /dev/null
+++ b/src/ui/desktop/menubar.h
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_DESKTOP_MENUBAR_H
+#define SEEN_DESKTOP_MENUBAR_H
+
+/**
+ * @file
+ * Desktop main menu bar code.
+ */
+/*
+ * Authors:
+ *   Tavmjong Bah
+ *
+ * Copyright (C) 2018 Authors
+ *
+ * The contents of this file may be used under the GNU General Public License Version 2 or later.
+ * Read the file 'COPYING' for more information.
+ *
+ */
+
+namespace Gtk {
+  class MenuBar;
+}
+
+namespace Inkscape {
+namespace UI {
+namespace View {
+  class View;
+}
+}
+}
+
+Gtk::MenuBar* build_menubar(Inkscape::UI::View::View* view);
+
+#endif // SEEN_DESKTOP_MENUBAR_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/ui/interface.cpp b/src/ui/interface.cpp
index 496a03bae..45736da52 100644
--- a/src/ui/interface.cpp
+++ b/src/ui/interface.cpp
@@ -20,27 +20,15 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
-#include <gtkmm/radiomenuitem.h>
-#include <gtkmm/separatormenuitem.h>
-#include <glibmm/miscutils.h>
-
-#include "desktop-style.h"
 #include "desktop.h"
-#include "document-undo.h"
 #include "document.h"
 #include "enums.h"
 #include "file.h"
-#include "gradient-drag.h"
 #include "inkscape.h"
 #include "inkscape-window.h"
-#include "message-context.h"
-#include "message-stack.h"
 #include "preferences.h"
-#include "selection-chemistry.h"
 #include "shortcuts.h"
 
-#include "display/sp-canvas.h"
-
 #include "extension/db.h"
 #include "extension/effect.h"
 #include "extension/find_extension_by_mime.h"
@@ -48,48 +36,23 @@
 
 #include "helper/action.h"
 
-#include "ui/icon-loader.h"
-
 #include "io/sys.h"
 
-#include "object/sp-anchor.h"
-#include "object/sp-clippath.h"
-#include "object/sp-flowtext.h"
-#include "object/sp-image.h"
-#include "object/sp-item-group.h"
-#include "object/sp-mask.h"
 #include "object/sp-namedview.h"
 #include "object/sp-root.h"
-#include "object/sp-shape.h"
-#include "object/sp-text.h"
-#include "style.h"
 
-#include "svg/svg-color.h"
-
-#include "ui/clipboard.h"
-#include "ui/contextmenu.h"
 #include "ui/dialog-events.h"
 #include "ui/dialog/dialog-manager.h"
 #include "ui/dialog/inkscape-preferences.h"
 #include "ui/dialog/layer-properties.h"
 #include "ui/interface.h"
-#include "ui/monitor.h"
-#include "ui/tools/tool-base.h"
-#include "ui/uxmanager.h"
+
 #include "ui/view/svg-view-widget.h"
 
 #include "widgets/desktop-widget.h"
-#include "widgets/ege-paint-def.h"
-
-using Inkscape::DocumentUndo;
-
-static bool temporarily_block_actions = false;
 
 static void sp_ui_import_one_file(char const *filename);
 static void sp_ui_import_one_file_with_check(gpointer filename, gpointer unused);
-static void sp_ui_menu_item_set_name(GtkWidget *data,
-                                     Glib::ustring const &name);
-static void sp_recent_open(GtkRecentChooser *, gpointer);
 
 void
 sp_ui_new_view()
@@ -204,47 +167,6 @@ sp_ui_close_all()
     return TRUE;
 }
 
-/*
- * Some day when the right-click menus are ready to start working
- * smarter with the verbs, we'll need to change this NULL being
- * sent to sp_action_perform to something useful, or set some kind
- * of global "right-clicked position" variable for actions to
- * investigate when they're called.
- */
-static void
-sp_ui_menu_activate(void */*object*/, SPAction *action)
-{
-    if (!temporarily_block_actions) {
-        sp_action_perform(action, nullptr);
-    }
-}
-
-static void
-sp_ui_menu_select_action(void */*object*/, SPAction *action)
-{
-    sp_action_get_view(action)->tipsMessageContext()->set(Inkscape::NORMAL_MESSAGE, action->tip);
-}
-
-static void
-sp_ui_menu_deselect_action(void */*object*/, SPAction *action)
-{
-    sp_action_get_view(action)->tipsMessageContext()->clear();
-}
-
-static void
-sp_ui_menu_select(gpointer object, gpointer tip)
-{
-    Inkscape::UI::View::View *view = static_cast<Inkscape::UI::View::View*> (g_object_get_data(G_OBJECT(object), "view"));
-    view->tipsMessageContext()->set(Inkscape::NORMAL_MESSAGE, (gchar *)tip);
-}
-
-static void
-sp_ui_menu_deselect(gpointer object)
-{
-    Inkscape::UI::View::View *view = static_cast<Inkscape::UI::View::View*>  (g_object_get_data(G_OBJECT(object), "view"));
-    view->tipsMessageContext()->clear();
-}
-
 
 void
 sp_ui_dialog_title_string(Inkscape::Verb *verb, gchar *c)
@@ -274,114 +196,6 @@ sp_ui_dialog_title_string(Inkscape::Verb *verb, gchar *c)
     }
 }
 
-/* install CSS to shift icons into the space reserved for toggles (i.e. check and radio items)
- *
- * TODO: This code already exists as a C++ version in the class ContextMenu so we can simply wrap it here.
- *       In future ContextMenu and the (to be created) class for the menu bar should then be derived from one common base class.
- */
-void shift_icons(GtkWidget *menu, gpointer /* user_data */)
-{
-    ContextMenu *contextmenu = static_cast<ContextMenu *>(Glib::wrap(menu));
-    contextmenu->ShiftIcons();
-}
-
-/**
- * Appends a custom menu UI from a verb.
- *
- * @see ContextMenu::AppendItemFromVerb for a c++ified alternative. Consider dropping sp_ui_menu_append_item_from_verb when c++ifying interface.cpp.
- *
- * @param menu      The menu to which the item will be appended
- * @param verb      The verb from which the item's label, action and icon (optionally) will be read
- * @param view
- * @param show_icon True if an icon should be displayed before the menu item's label
- * @param radio     True if a radio button should be displayed next to the menu item
- * @param group     The radio button group that the item should belong to
- *
- * @details The show_icon flag should be used very sparingly because menu icons are not recommended
- *          any longer under the GNOME HIG.  Also, note that the text appears after the icon, and
- *          so will be indented relative to "normal" menu items.  As such, menus will look best if
- *          all the items with icons are grouped together between a pair of separators.
- */
-static GtkWidget *sp_ui_menu_append_item_from_verb(GtkMenu                  *menu,
-                                                   Inkscape::Verb           *verb,
-                                                   Inkscape::UI::View::View *view,
-                                                   bool                      show_icon = false,
-                                                   bool                      radio     = false,
-                                                   Gtk::RadioMenuItem::Group *group    = nullptr)
-{
-    Gtk::Widget *item;
-
-    // Just create a menu separator if this isn't a real action. Otherwise, create a real menu item
-    if (verb->get_code() == SP_VERB_NONE) {
-        item = new Gtk::SeparatorMenuItem();
-    } else {
-        SPAction *action = verb->get_action(Inkscape::ActionContext(view));
-
-        if (!action) return nullptr;
-
-        // Create the menu item itself, either as a radio menu item, or just
-        // a regular menu item depending on whether the "radio" flag is set
-        if (radio) {
-            item = new Gtk::RadioMenuItem(*group);
-        } else {
-            item = new Gtk::MenuItem();
-        }
-
-        // Now create the label and add it to the menu item
-        GtkWidget *label = gtk_accel_label_new(action->name);
-        gtk_label_set_markup_with_mnemonic( GTK_LABEL(label), action->name);
-
-#if GTK_CHECK_VERSION(3,16,0)
-        gtk_label_set_xalign(GTK_LABEL(label), 0.0);
-#else
-        gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
-#endif
-        sp_shortcut_add_accelerator(item->gobj(), sp_shortcut_get_primary(verb));
-        gtk_accel_label_set_accel_widget(GTK_ACCEL_LABEL(label), item->gobj());
-
-        // If there is an image associated with the action, then we can add it as an icon for the menu item.
-        if (show_icon && action->image) {
-            item->set_name("ImageMenuItem");  // custom name to identify our "ImageMenuItems"
-            GtkWidget *icon = sp_get_icon_image(action->image, GTK_ICON_SIZE_MENU);
-
-            // create a box to hold icon and label as GtkMenuItem derives from GtkBin and can only hold one child
-            GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
-            gtk_box_pack_start(GTK_BOX(box), icon, FALSE, FALSE, 0);
-            gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
-
-            gtk_container_add(GTK_CONTAINER(item->gobj()), box);
-        } else {
-            gtk_container_add(GTK_CONTAINER(item->gobj()), label);
-        }
-
-        action->signal_set_sensitive.connect(
-            sigc::bind<0>(
-                sigc::ptr_fun(&gtk_widget_set_sensitive),
-                item->gobj()));
-        action->signal_set_name.connect(
-            sigc::bind<0>(
-                sigc::ptr_fun(&sp_ui_menu_item_set_name),
-                item->gobj()));
-
-        if (!action->sensitive) {
-            item->set_sensitive(false);
-        }
-
-        gtk_widget_set_events(item->gobj(), GDK_KEY_PRESS_MASK);
-
-        g_object_set_data(G_OBJECT(item->gobj()), "view", (gpointer) view);
-        g_signal_connect( G_OBJECT(item->gobj()), "activate", G_CALLBACK(sp_ui_menu_activate), action );
-        g_signal_connect( G_OBJECT(item->gobj()), "select", G_CALLBACK(sp_ui_menu_select_action), action );
-        g_signal_connect( G_OBJECT(item->gobj()), "deselect", G_CALLBACK(sp_ui_menu_deselect_action), action );
-    }
-
-    item->show_all();
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item->gobj());
-
-    return item->gobj();
-
-} // end of sp_ui_menu_append_item_from_verb
-
 
 Glib::ustring getLayoutPrefPath( Inkscape::UI::View::View *view )
 {
@@ -398,402 +212,6 @@ Glib::ustring getLayoutPrefPath( Inkscape::UI::View::View *view )
     return prefPath;
 }
 
-static void
-checkitem_toggled(GtkCheckMenuItem *menuitem, gpointer user_data)
-{
-    gchar const *pref = (gchar const *) user_data;
-    Inkscape::UI::View::View *view = (Inkscape::UI::View::View *) g_object_get_data(G_OBJECT(menuitem), "view");
-    SPAction *action = (SPAction *) g_object_get_data(G_OBJECT(menuitem), "action");
-
-    if (action) {
-
-        sp_ui_menu_activate(menuitem, action);
-
-    } else if (pref) {
-        // All check menu items should have actions now, but just in case
-        Glib::ustring pref_path = getLayoutPrefPath( view );
-        pref_path += pref;
-        pref_path += "/state";
-
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        gboolean checked = gtk_check_menu_item_get_active(menuitem);
-        prefs->setBool(pref_path, checked);
-
-        reinterpret_cast<SPDesktop*>(view)->layoutWidget();
-    }
-}
-
-static bool getViewStateFromPref(Inkscape::UI::View::View *view, gchar const *pref)
-{
-    Glib::ustring pref_path = getLayoutPrefPath( view );
-    pref_path += pref;
-    pref_path += "/state";
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    return prefs->getBool(pref_path, true);
-}
-
-static gboolean checkitem_update(GtkWidget *widget, cairo_t * /*cr*/, gpointer user_data)
-{
-    GtkCheckMenuItem *menuitem=GTK_CHECK_MENU_ITEM(widget);
-
-    gchar const *pref = (gchar const *) user_data;
-    Inkscape::UI::View::View *view = (Inkscape::UI::View::View *) g_object_get_data(G_OBJECT(menuitem), "view");
-    SPAction *action = (SPAction *) g_object_get_data(G_OBJECT(menuitem), "action");
-    SPDesktop *dt = static_cast<SPDesktop*>(view);
-
-    bool ison = false;
-    if (action) {
-
-        if (!strcmp(action->id, "ToggleGrid")) {
-            ison = dt->gridsEnabled();
-        } else if (!strcmp(action->id, "EditGuidesToggleLock")) {
-            ison = dt->namedview->lockguides;
-        } else if (!strcmp(action->id, "ToggleGuides")) {
-            ison = dt->namedview->getGuides();
-        } else if (!strcmp(action->id, "ViewCmsToggle")) {
-            ison = dt->colorProfAdjustEnabled();
-        } else if (!strcmp(action->id, "ViewSplitModeToggle")) {
-            ison = dt->splitMode();
-        } else if (!strcmp(action->id, "ViewXRayToggle")) {
-            ison = dt->xrayMode();
-        } else {
-            ison = getViewStateFromPref(view, pref);
-        }
-    } else if (pref) {
-        // The Show/Hide menu items without actions
-        ison = getViewStateFromPref(view, pref);
-    }
-
-    g_signal_handlers_block_by_func(G_OBJECT(menuitem), (gpointer)(GCallback)checkitem_toggled, user_data);
-    gtk_check_menu_item_set_active(menuitem, ison);
-    g_signal_handlers_unblock_by_func(G_OBJECT(menuitem), (gpointer)(GCallback)checkitem_toggled, user_data);
-
-    return FALSE;
-}
-
-
-static void taskToggled(GtkCheckMenuItem *menuitem, gpointer userData)
-{
-    if ( gtk_check_menu_item_get_active(menuitem) ) {
-        gint taskNum = GPOINTER_TO_INT(userData);
-        taskNum = (taskNum < 0) ? 0 : (taskNum > 2) ? 2 : taskNum;
-
-        Inkscape::UI::View::View *view = (Inkscape::UI::View::View *) g_object_get_data(G_OBJECT(menuitem), "view");
-
-        // note: this will change once more options are in the task set support:
-        Inkscape::UI::UXManager::getInstance()->setTask( dynamic_cast<SPDesktop*>(view), taskNum );
-    }
-}
-
-
-/**
- * Callback function to update the status of the radio buttons in the View -> Display mode menu (Normal, No Filters, Outline) and Color display mode.
- */
-static gboolean update_view_menu(GtkWidget *widget, cairo_t * /*cr*/, gpointer user_data)
-{
-    SPAction *action = (SPAction *) user_data;
-    g_assert(action->id != nullptr);
-
-    Inkscape::UI::View::View *view = (Inkscape::UI::View::View *) g_object_get_data(G_OBJECT(widget), "view");
-    SPDesktop *dt = static_cast<SPDesktop*>(view);
-    Inkscape::RenderMode mode = dt->getMode();
-    Inkscape::ColorMode colormode = dt->getColorMode();
-
-    bool new_state = false;
-    if (!strcmp(action->id, "ViewModeNormal")) {
-        new_state = mode == Inkscape::RENDERMODE_NORMAL;
-    } else if (!strcmp(action->id, "ViewModeNoFilters")) {
-        new_state = mode == Inkscape::RENDERMODE_NO_FILTERS;
-    } else if (!strcmp(action->id, "ViewModeOutline")) {
-        new_state = mode == Inkscape::RENDERMODE_OUTLINE;
-    } else if (!strcmp(action->id, "ViewModeVisibleHairlines")) {
-        new_state = mode == Inkscape::RENDERMODE_VISIBLE_HAIRLINES;
-    } else if (!strcmp(action->id, "ViewColorModeNormal")) {
-        new_state = colormode == Inkscape::COLORMODE_NORMAL;
-    } else if (!strcmp(action->id, "ViewColorModeGrayscale")) {
-        new_state = colormode == Inkscape::COLORMODE_GRAYSCALE;
-    } else if (!strcmp(action->id, "ViewColorModePrintColorsPreview")) {
-        new_state = colormode == Inkscape::COLORMODE_PRINT_COLORS_PREVIEW;
-    } else {
-        g_warning("update_view_menu does not handle this verb");
-    }
-
-    if (new_state) { //only one of the radio buttons has to be activated; the others will automatically be deactivated
-        if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget))) {
-            // When the GtkMenuItem version of the "activate" signal has been emitted by a GtkRadioMenuItem, there is a second
-            // emission as the most recently active item is toggled to inactive. This is dealt with before the original signal is handled.
-            // This emission however should not invoke any actions, hence we block it here:
-            temporarily_block_actions = true;
-            gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (widget), TRUE);
-            temporarily_block_actions = false;
-        }
-    }
-
-    return FALSE;
-}
-
-static void
-sp_ui_menu_append_check_item_from_verb(GtkMenu *menu, Inkscape::UI::View::View *view, gchar const *pref, Inkscape::Verb *verb)
-{
-    unsigned int shortcut = sp_shortcut_get_primary(verb);
-    SPAction *action = verb->get_action(Inkscape::ActionContext(view));
-    GtkWidget *item = gtk_check_menu_item_new_with_mnemonic(action->name);
-
-    sp_shortcut_add_accelerator(item, shortcut);
-
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
-
-    g_object_set_data(G_OBJECT(item), "view", (gpointer) view);
-    g_object_set_data(G_OBJECT(item), "action", (gpointer) action);
-
-    g_signal_connect( G_OBJECT(item), "toggled", (GCallback) checkitem_toggled, (void *) pref);
-    g_signal_connect( G_OBJECT(item), "draw", (GCallback) checkitem_update, (void *) pref);
-
-    checkitem_update(item, nullptr, (void *)pref);
-
-    g_signal_connect( G_OBJECT(item), "select", G_CALLBACK(sp_ui_menu_select_action), action );
-    g_signal_connect( G_OBJECT(item), "deselect", G_CALLBACK(sp_ui_menu_deselect_action), action );
-}
-
-static void
-sp_recent_open(GtkRecentChooser *recent_menu, gpointer /*user_data*/)
-{
-    // dealing with the bizarre filename convention in Inkscape for now
-    gchar *uri = gtk_recent_chooser_get_current_uri(GTK_RECENT_CHOOSER(recent_menu));
-    gchar *local_fn = g_filename_from_uri(uri, nullptr, nullptr);
-    gchar *utf8_fn = g_filename_to_utf8(local_fn, -1, nullptr, nullptr, nullptr);
-    sp_file_open(utf8_fn, nullptr);
-    g_free(utf8_fn);
-    g_free(local_fn);
-    g_free(uri);
-}
-
-static void
-sp_ui_checkboxes_menus(GtkMenu *m, Inkscape::UI::View::View *view)
-{
-    //sp_ui_menu_append_check_item_from_verb(m, view, "menu", 0);
-    sp_ui_menu_append_check_item_from_verb(m, view, "commands",
-                                           Inkscape::Verb::get(SP_VERB_TOGGLE_COMMANDS_TOOLBAR));
-    sp_ui_menu_append_check_item_from_verb(m, view,"snaptoolbox",
-                                           Inkscape::Verb::get(SP_VERB_TOGGLE_SNAP_TOOLBAR));
-    sp_ui_menu_append_check_item_from_verb(m, view, "toppanel",
-                                           Inkscape::Verb::get(SP_VERB_TOGGLE_TOOL_TOOLBAR));
-    sp_ui_menu_append_check_item_from_verb(m, view, "toolbox",
-                                           Inkscape::Verb::get(SP_VERB_TOGGLE_TOOLBOX));
-    sp_ui_menu_append_check_item_from_verb(m, view, "rulers",
-                                           Inkscape::Verb::get(SP_VERB_TOGGLE_RULERS));
-    sp_ui_menu_append_check_item_from_verb(m, view, "scrollbars",
-                                           Inkscape::Verb::get(SP_VERB_TOGGLE_SCROLLBARS));
-    sp_ui_menu_append_check_item_from_verb(m, view, "panels",
-                                           Inkscape::Verb::get(SP_VERB_TOGGLE_PALETTE));
-    sp_ui_menu_append_check_item_from_verb(m, view, "statusbar",
-                                           Inkscape::Verb::get(SP_VERB_TOGGLE_STATUSBAR));
-}
-
-
-static void addTaskMenuItems(GtkMenu *menu, Inkscape::UI::View::View *view)
-{
-    gchar const* data[] = {
-        C_("Interface setup", "Default"), _("Default interface setup"),
-        C_("Interface setup", "Custom"), _("Setup for custom task"),
-        C_("Interface setup", "Wide"), _("Setup for widescreen work"),
-        nullptr, nullptr
-    };
-
-    Gtk::RadioMenuItem::Group group;
-    int count = 0;
-    gint active = Inkscape::UI::UXManager::getInstance()->getDefaultTask( dynamic_cast<SPDesktop*>(view) );
-    for (gchar const **strs = data; strs[0]; strs += 2, count++)
-    {
-        Gtk::RadioMenuItem *item = new Gtk::RadioMenuItem(group,Glib::ustring(strs[0]));
-        if ( count == active )
-        {
-            item->set_active();
-        }
-
-        g_object_set_data( G_OBJECT(item->gobj()), "view", view );
-        g_signal_connect( G_OBJECT(item->gobj()), "toggled", reinterpret_cast<GCallback>(taskToggled), GINT_TO_POINTER(count) );
-        g_signal_connect( G_OBJECT(item->gobj()), "select", G_CALLBACK(sp_ui_menu_select), const_cast<gchar*>(strs[1]) );
-        g_signal_connect( G_OBJECT(item->gobj()), "deselect", G_CALLBACK(sp_ui_menu_deselect), 0 );
-
-        item->show();
-        gtk_menu_shell_append( GTK_MENU_SHELL(menu), GTK_WIDGET(item->gobj()) );
-    }
-}
-
-
-/**
- * Observer that updates the recent list's max document count.
- */
-class MaxRecentObserver : public Inkscape::Preferences::Observer {
-public:
-    MaxRecentObserver(GtkWidget *recent_menu) :
-        Observer("/options/maxrecentdocuments/value"),
-        _rm(recent_menu)
-    {}
-    void notify(Inkscape::Preferences::Entry const &e) override {
-        gtk_recent_chooser_set_limit(GTK_RECENT_CHOOSER(_rm), e.getInt());
-        // hack: the recent menu doesn't repopulate after changing the limit, so we force it
-        g_signal_emit_by_name((gpointer) gtk_recent_manager_get_default(), "changed");
-    }
-private:
-    GtkWidget *_rm;
-};
-
-/**
- * This function turns XML into a menu.
- *
- *  This function is realitively simple as it just goes through the XML
- *  and parses the individual elements.  In the case of a submenu, it
- *  just calls itself recursively.  Because it is only reasonable to have
- *  a couple of submenus, it is unlikely this will go more than two or
- *  three times.
- *
- *  In the case of an unrecognized verb, a menu item is made to identify
- *  the verb that is missing, and display that.  The menu item is also made
- *  insensitive.
- *
- * @param  menus        This is the XML that defines the menu
- * @param  menu         Menu to be added to
- * @param  view         The View that this menu is being built for
- * @param  show_icons   Whether to show icons (can be overridden by the current XML::Node and preferences)
- */
-static void sp_ui_build_dyn_menus(Inkscape::XML::Node *menus, GtkWidget *menu, Inkscape::UI::View::View *view,
-                                  bool show_icons = true)
-{
-    if (menus == nullptr) return;
-    if (menu == nullptr)  return;
-    Gtk::RadioMenuItem::Group group;
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    int show_icons_pref = prefs->getInt("/theme/menuIcons", 0);
-
-    for (Inkscape::XML::Node *menu_pntr = menus; menu_pntr != nullptr; menu_pntr = menu_pntr->next()) {
-
-        // Check if the "show-icons" attribute is set, and set the flag here accordingly
-        bool show_icons_curr = show_icons;
-        if (show_icons_pref == 1) {          // enable all icons
-            show_icons_curr = true;
-        } else if (show_icons_pref == -1) {  // disable all icons
-            show_icons_curr = false;
-        } else {                             // read from XML file or inherit (=keep) previous value if unset
-            const char *str = menu_pntr->attribute("show-icons");
-            if (str) {
-                if (!g_ascii_strcasecmp(str, "yes") || !g_ascii_strcasecmp(str, "true") || !g_ascii_strcasecmp(str, "1")) {
-                    show_icons_curr = true;
-                } else if (!g_ascii_strcasecmp(str, "no") || !g_ascii_strcasecmp(str, "false") || !g_ascii_strcasecmp(str, "0")) {
-                    show_icons_curr = false;
-                } else {
-                    g_warning("Invalid value for attribute 'show-icons': '%s'", str);
-                }
-            }
-        }
-
-        if (!strcmp(menu_pntr->name(), "inkscape")) {
-            sp_ui_build_dyn_menus(menu_pntr->firstChild(), menu, view, show_icons_curr);
-        }
-        if (!strcmp(menu_pntr->name(), "submenu")) {
-            GtkWidget *mitem;
-            if (menu_pntr->attribute("_name") != nullptr) {
-                mitem = gtk_menu_item_new_with_mnemonic(_(menu_pntr->attribute("_name")));
-            } else {
-                mitem = gtk_menu_item_new_with_mnemonic(menu_pntr->attribute("name"));
-            }
-            GtkWidget *submenu = gtk_menu_new();
-            sp_ui_build_dyn_menus(menu_pntr->firstChild(), submenu, view, show_icons_curr);
-            gtk_menu_item_set_submenu(GTK_MENU_ITEM(mitem), GTK_WIDGET(submenu));
-            gtk_menu_shell_append(GTK_MENU_SHELL(menu), mitem);
-            g_signal_connect(submenu, "map", G_CALLBACK(shift_icons), NULL);
-            continue;
-        }
-        if (!strcmp(menu_pntr->name(), "verb")) {
-            gchar const *verb_name = menu_pntr->attribute("verb-id");
-            Inkscape::Verb *verb = Inkscape::Verb::getbyid(verb_name);
-
-            if (verb != nullptr) {
-                if (menu_pntr->attribute("radio") != nullptr) {
-                    GtkWidget *item = sp_ui_menu_append_item_from_verb (GTK_MENU(menu), verb, view, false, true, &group);
-                    if (menu_pntr->attribute("default") != nullptr) {
-                        gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), TRUE);
-                    }
-                    if (verb->get_code() != SP_VERB_NONE) {
-                        SPAction *action = verb->get_action(Inkscape::ActionContext(view));
-                        g_signal_connect( G_OBJECT(item), "draw", (GCallback) update_view_menu, (void *) action);
-                    }
-                } else if (menu_pntr->attribute("check") != nullptr) {
-                    if (verb->get_code() != SP_VERB_NONE) {
-                        SPAction *action = verb->get_action(Inkscape::ActionContext(view));
-                        sp_ui_menu_append_check_item_from_verb(GTK_MENU(menu), view, nullptr, verb);
-                    }
-                } else {
-                    sp_ui_menu_append_item_from_verb(GTK_MENU(menu), verb, view, show_icons_curr);
-                    Gtk::RadioMenuItem::Group group2;
-                    group = group2;
-                }
-            } else {
-                gchar string[120];
-                g_snprintf(string, 120, _("Verb \"%s\" Unknown"), verb_name);
-                string[119] = '\0'; /* may not be terminated */
-                GtkWidget *item = gtk_menu_item_new_with_label(string);
-                gtk_widget_set_sensitive(item, false);
-                gtk_widget_show(item);
-                gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
-            }
-            continue;
-        }
-        if (!strcmp(menu_pntr->name(), "separator")) {
-            GtkWidget *item = gtk_separator_menu_item_new();
-            gtk_widget_show(item);
-            gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
-            continue;
-        }
-
-        if (!strcmp(menu_pntr->name(), "recent-file-list")) {
-            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-            // create recent files menu
-            int max_recent = prefs->getInt("/options/maxrecentdocuments/value");
-            GtkWidget *recent_menu = gtk_recent_chooser_menu_new_for_manager(gtk_recent_manager_get_default());
-            gtk_recent_chooser_set_limit(GTK_RECENT_CHOOSER(recent_menu), max_recent);
-            // sort most recently used documents first to preserve previous behavior
-            gtk_recent_chooser_set_sort_type(GTK_RECENT_CHOOSER(recent_menu), GTK_RECENT_SORT_MRU);
-            g_signal_connect(G_OBJECT(recent_menu), "item-activated", G_CALLBACK(sp_recent_open), (gpointer) nullptr);
-
-            // add filter to only open files added by Inkscape
-            GtkRecentFilter *inkscape_only_filter = gtk_recent_filter_new();
-            gtk_recent_filter_add_application(inkscape_only_filter, g_get_prgname());
-            gtk_recent_chooser_add_filter(GTK_RECENT_CHOOSER(recent_menu), inkscape_only_filter);
-
-            gtk_recent_chooser_set_show_tips (GTK_RECENT_CHOOSER(recent_menu), TRUE);
-            gtk_recent_chooser_set_show_not_found (GTK_RECENT_CHOOSER(recent_menu), FALSE);
-
-            GtkWidget *recent_item = gtk_menu_item_new_with_mnemonic(_("Open _Recent"));
-            gtk_menu_item_set_submenu(GTK_MENU_ITEM(recent_item), recent_menu);
-
-            gtk_menu_shell_append(GTK_MENU_SHELL(menu), GTK_WIDGET(recent_item));
-            // this will just sit and update the list's item count
-            static MaxRecentObserver *mro = new MaxRecentObserver(recent_menu);
-            prefs->addObserver(*mro);
-            continue;
-        }
-        if (!strcmp(menu_pntr->name(), "objects-checkboxes")) {
-            sp_ui_checkboxes_menus(GTK_MENU(menu), view);
-            continue;
-        }
-        if (!strcmp(menu_pntr->name(), "task-checkboxes")) {
-            addTaskMenuItems(GTK_MENU(menu), view);
-            continue;
-        }
-    }
-}
-
-GtkWidget *sp_ui_main_menubar(Inkscape::UI::View::View *view)
-{
-    GtkWidget *mbar = gtk_menu_bar_new();
-    sp_ui_build_dyn_menus(INKSCAPE.get_menus()->parent(), mbar, view);
-    return mbar;
-}
 
 void
 sp_ui_import_files(gchar *buffer)
@@ -883,35 +301,6 @@ sp_ui_overwrite_file(gchar const *filename)
     return return_value;
 }
 
-static void
-sp_ui_menu_item_set_name(GtkWidget *data, Glib::ustring const &name)
-{
-    if (data || GTK_IS_BIN (data)) {
-        void *child = gtk_bin_get_child (GTK_BIN (data));
-        // child is either
-        // - a GtkLabel (if the menu has no accel key or icon)
-        // - a GtkBox (if item has an accel key or image)
-        //   in which case we need to find the GtkLabel in the box
-        // - something else we do not expect (yet)
-        if (child != nullptr) {
-            if (GTK_IS_LABEL(child)) {
-                gtk_label_set_markup_with_mnemonic(GTK_LABEL (child), name.c_str());
-            } else if (GTK_IS_BOX(child)) {
-                std::vector<Gtk::Widget*> children = Glib::wrap(GTK_CONTAINER(child))->get_children();
-                for (auto child: children) {
-                    Gtk::Label *label = dynamic_cast<Gtk::Label *>(child);
-                    if (label) {
-                        label->set_markup_with_mnemonic(name);
-                        break;
-                    }
-                }
-            } else {
-                // sp_ui_menu_append_item_from_verb might have learned to set a menu item in yet another way...
-                g_assert_not_reached();
-            }
-        }
-    }
-}
 /*
   Local Variables:
   mode:c++
diff --git a/src/ui/interface.h b/src/ui/interface.h
index eb75fe7d6..67cb0f393 100644
--- a/src/ui/interface.h
+++ b/src/ui/interface.h
@@ -54,18 +54,6 @@ void sp_ui_import_files(gchar *buffer);
  */
 unsigned int sp_ui_close_all ();
 
-/**
- * Build the main tool bar.
- *
- * Currently the main tool bar is built as a dynamic XML menu using
- * \c sp_ui_build_dyn_menus.  This function builds the bar, and then
- * pass it to get items attached to it.
- *
- * @param  view  View to build the bar for
- */
-GtkWidget *sp_ui_main_menubar (Inkscape::UI::View::View *view);
-
-void sp_menu_append_recent_documents (GtkWidget *menu);
 void sp_ui_dialog_title_string (Inkscape::Verb * verb, char* c);
 
 Glib::ustring getLayoutPrefPath( Inkscape::UI::View::View *view );