Adding upstream version 1.2.2.upstream/1.2.2upstream

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

1 files changed, 322 insertions, 0 deletions

diff --git a/src/ui/desktop/menubar.cpp b/src/ui/desktop/menubar.cpp
new file mode 100644
index 0000000..a686070
--- /dev/null
+++ b/src/ui/desktop/menubar.cpp
@@ -0,0 +1,322 @@
+// 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>
+ *   Sushant A.A.       <sushant.co19@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 "menubar.h"
+
+#include <iostream>
+#include <iomanip>
+#include <map>
+#include <regex>
+
+#include <glibmm/i18n.h>
+
+#include "inkscape-application.h" // Open recent
+#include "preferences.h"          // Use icons or not
+#include "io/resource.h"          // UI File location
+
+// =================== Main Menu ================
+void
+build_menu()
+{
+    std::string filename = Inkscape::IO::Resource::get_filename(Inkscape::IO::Resource::UIS, "menus.ui");
+    auto refBuilder = Gtk::Builder::create();
+
+    try
+    {
+        refBuilder->add_from_file(filename);
+    }
+    catch (const Glib::Error& err)
+    {
+        std::cerr << "build_menu: failed to load Main menu from: "
+                    << filename <<": "
+                    << err.what().raw() << std::endl;
+    }
+
+    const auto object = refBuilder->get_object("menus");
+#if GTK_CHECK_VERSION(4, 0 ,0)
+    const auto gmenu = std::dynamic_pointer_cast<Gio::Menu>(object);
+#else
+    const auto gmenu = Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
+#endif
+
+    if (!gmenu) {
+        std::cerr << "build_menu: failed to build Main menu!" << std::endl;
+    } else {
+
+        static auto app = InkscapeApplication::instance();
+        std::map<Glib::ustring, Glib::ustring>& label_to_tooltip_map = app->get_menu_label_to_tooltip_map();
+        label_to_tooltip_map.clear();
+
+        { // Filters and Extensions
+
+            auto effects_object = refBuilder->get_object("effect-menu-effects");
+            auto filters_object = refBuilder->get_object("filter-menu-filters");
+            auto effects_menu   = Glib::RefPtr<Gio::Menu>::cast_dynamic(effects_object);
+            auto filters_menu   = Glib::RefPtr<Gio::Menu>::cast_dynamic(filters_object);
+
+            if (!filters_menu) {
+                std::cerr << "build_menu(): Couldn't find Filters menu entry!" << std::endl;
+            }
+            if (!effects_menu) {
+                std::cerr << "build_menu(): Couldn't find Extensions menu entry!" << std::endl;
+            }
+
+            std::map<Glib::ustring, Glib::RefPtr<Gio::Menu>> submenus;
+
+            for (auto &[ entry_id, submenu_name_list, entry_name ] : app->get_action_effect_data().give_all_data())
+            {
+                if (submenu_name_list.size() > 0) {
+
+                    // Effect data is used for both filters menu and extensions menu... we need to
+                    // add to correct menu. 'submenu_name_list' either starts with 'Effects' or 'Filters'.
+                    // Note "Filters" is translated!
+                    Glib::ustring path; // Only used as index to map of submenus.
+                    auto top_menu = filters_menu;
+                    if (submenu_name_list.front() == "Effects") {
+                        top_menu = effects_menu;
+                        path += "Effects";
+                    } else {
+                        path += "Filters";
+                    }
+                    submenu_name_list.pop_front();
+
+                    if (top_menu) { // It's possible that the menu doesn't exist (Kid's Inkscape?)
+                        auto current_menu = top_menu;
+                        for (auto &submenu_name : submenu_name_list) {
+                            path += submenu_name + "-";
+                            auto it = submenus.find(path);
+                            if (it == submenus.end()) {
+                                auto new_gsubmenu = Gio::Menu::create();
+                                submenus[path] = new_gsubmenu;
+                                current_menu->append_submenu(submenu_name, new_gsubmenu);
+                                current_menu = new_gsubmenu;
+                            } else {
+                                current_menu = it->second;
+                            }
+                        }
+                        current_menu->append(entry_name, "app." + entry_id);
+                    } else {
+                        std::cerr << "build_menu(): menu doesn't exist!" << std::endl; // Warn for now.
+                    }
+                }
+            }
+        }
+
+        // Recent file
+        auto recent_manager = Gtk::RecentManager::get_default();
+
+        auto sub_object = refBuilder->get_object("recent-files");
+        auto sub_gmenu = Glib::RefPtr<Gio::Menu>::cast_dynamic(sub_object);
+        auto recent_menu_quark = Glib::Quark("recent-manager");
+        sub_gmenu->set_data(recent_menu_quark, recent_manager.get()); // mark submenu, so we can find it
+
+        auto rebuild = [](Glib::RefPtr<Gio::Menu> submenu) {
+            auto recent_manager = Gtk::RecentManager::get_default();
+            submenu->remove_all();
+            int max_files = Inkscape::Preferences::get()->getInt("/options/maxrecentdocuments/value");
+            if (max_files <= 0) {
+                return;
+            }
+
+            auto recent_files = recent_manager->get_items(); // all recent files not necessarily inkscape only
+            // sort by "last modified" time, which puts the most recently opened files first
+            std::sort(begin(recent_files), end(recent_files),
+                [](Glib::RefPtr<Gtk::RecentInfo> a, Glib::RefPtr<Gtk::RecentInfo> b) -> bool {
+                    return a->get_modified() > b->get_modified();
+                }
+            );
+
+            unsigned inserted_entries = 0;
+            for (auto const &recent_file : recent_files) {
+                // check if given was generated by inkscape
+                bool valid_file = recent_file->has_application(g_get_prgname()) ||
+                                recent_file->has_application("org.inkscape.Inkscape") ||
+                                recent_file->has_application("inkscape")
+#ifdef _WIN32
+                                || recent_file->has_application("inkscape.exe")
+#endif
+                                ;
+
+                // this is potentially expensive: local FS access (remote files are not checked)
+                valid_file = valid_file && recent_file->exists();
+
+                if (!valid_file) {
+                    continue;
+                }
+
+                // Escape underscores to prevent them from being interpreted as accelerator mnemonics
+                std::regex underscore{"_"};
+                std::string const dunder{"__"};
+                std::string raw_name = recent_file->get_short_name();
+                Glib::ustring escaped = std::regex_replace(raw_name, underscore, dunder);
+
+                auto item { Gio::MenuItem::create(std::move(escaped), Glib::ustring()) };
+                auto target { Glib::Variant<Glib::ustring>::create(recent_file->get_uri_display()) };
+                // note: setting action and target separately rather than using convenience menu method append
+                // since some filename characters can result in invalid "direct action" string
+                item->set_action_and_target(Glib::ustring("app.file-open-window"), target);
+                submenu->append_item(item);
+                inserted_entries++;
+
+                if (--max_files == 0) {
+                    break;
+                }
+            }
+
+            if (!inserted_entries) { // Create a placeholder with a non-existent action
+                auto nothing2c = Gio::MenuItem::create(_("No items found"), "app.nop");
+                submenu->append_item(nothing2c);
+            }
+        };
+
+        rebuild(sub_gmenu);
+
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        auto useicons = static_cast<UseIcons>(prefs->getInt("/theme/menuIcons", 0));
+
+        // Remove all or some icons. Also create label to tooltip map.
+        auto gmenu_copy = Gio::Menu::create();
+        // menu gets recreated; keep track of new recent items submenu
+        rebuild_menu(gmenu, gmenu_copy, useicons, recent_menu_quark, sub_gmenu);
+        app->gtk_app()->set_menubar(gmenu_copy);
+
+        // rebuild recent items submenu when the list changes
+        recent_manager->signal_changed().connect([=](){ rebuild(sub_gmenu); });
+    }
+}
+
+
+/*
+ * Disable all or some menu icons.
+ *
+ * This is quite nasty:
+ *
+ * We must disable icons in the Gio::Menu as there is no way to pass
+ * the needed information to the children of Gtk::PopoverMenu and no
+ * way to set visibility via CSS.
+ *
+ * MenuItems are immutable and not copyable so you have to recreate
+ * the menu tree. The format for accessing MenuItem data is not the
+ * same as what you need to create a new MenuItem.
+ *
+ * NOTE: Input is a Gio::MenuModel, Output is a Gio::Menu!!
+ */
+#if GTK_CHECK_VERSION(4, 0, 0)
+void rebuild_menu (std::shared_ptr<Gio::MenuModel> menu, std::shared_ptr<Gio::Menu> menu_copy, UseIcons useIcons, Glib::Quark quark, Glib::RefPtr<Gio::Menu>& recent_files) {
+#else
+void rebuild_menu (Glib::RefPtr<Gio::MenuModel>    menu, Glib::RefPtr<Gio::Menu>    menu_copy, UseIcons useIcons, Glib::Quark quark, Glib::RefPtr<Gio::Menu>& recent_files) {
+#endif
+
+    static auto app = InkscapeApplication::instance();
+    auto& extra_data = app->get_action_extra_data();
+    auto& label_to_tooltip_map = app->get_menu_label_to_tooltip_map();
+
+    for (int i = 0; i < menu->get_n_items(); ++i) {
+
+        Glib::ustring label;
+        Glib::ustring action;
+        Glib::ustring target;
+        Glib::VariantBase icon;
+        Glib::ustring use_icon;
+        std::map<Glib::ustring, Glib::VariantBase> attributes;
+
+        auto attribute_iter = menu->iterate_item_attributes(i);
+        while (attribute_iter->next()) {
+
+            // Attributes we need to create MenuItem or set icon.
+            if          (attribute_iter->get_name() == "label") {
+                // Convert label while preserving unicode translations
+                label = Glib::VariantBase::cast_dynamic<Glib::Variant<std::string> >(attribute_iter->get_value()).get();
+            } else if   (attribute_iter->get_name() == "action") {
+                action  = attribute_iter->get_value().print();
+                action.erase(0, 1);
+                action.erase(action.size()-1, 1);
+            } else if   (attribute_iter->get_name() == "target") {
+                target  = attribute_iter->get_value().print();
+            } else if   (attribute_iter->get_name() == "icon") {
+                icon     = attribute_iter->get_value();
+            } else if (attribute_iter->get_name() == "use-icon") {
+                use_icon =  attribute_iter->get_value().print();
+            } else {
+                // All the remaining attributes.
+                attributes[attribute_iter->get_name()] = attribute_iter->get_value();
+            }
+        }
+        Glib::ustring detailed_action = action;
+        if (target.size() > 0) {
+            detailed_action += "(" + target + ")";
+        }
+
+        auto tooltip = extra_data.get_tooltip_for_action(detailed_action);
+        label_to_tooltip_map[label] = tooltip;
+
+        // std::cout << "  " << std::setw(30) << detailed_action
+        //           << "  label: " << std::setw(30) << label.c_str()
+        //           << "  use_icon (.ui): " << std::setw(6) << use_icon
+        //           << "  icon: " << (icon ? "yes" : "no ")
+        //           << "  useIcons: " << (int)useIcons
+        //           << "  use_icon.size(): " << use_icon.size()
+        //           << "  tooltip: " << tooltip.c_str()
+        //           << std::endl;
+
+        auto menu_item = Gio::MenuItem::create(label, detailed_action);
+        if (icon &&
+            (useIcons == UseIcons::always ||
+             (useIcons == UseIcons::as_requested && use_icon.size() > 0))) {
+            menu_item->set_attribute_value("icon", icon);
+        }
+
+        // Add remaining attributes
+        for (auto const& [key, value] : attributes) {
+            menu_item->set_attribute_value(key, value);
+        }
+
+        // Add submenus
+        auto link_iter = menu->iterate_item_links(i);
+        while (link_iter->next()) {
+            auto submenu = Gio::Menu::create();
+            if (link_iter->get_name() == "submenu") {
+                menu_item->set_submenu(submenu);
+                if (link_iter->get_value()->get_data(quark)) {
+                    recent_files = submenu;
+                }
+            } else if (link_iter->get_name() == "section") {
+                menu_item->set_section(submenu);
+            } else {
+                std::cerr << "rebuild_menu: Unknown link type: " << link_iter->get_name() << std::endl;
+            }
+            rebuild_menu (link_iter->get_value(), submenu, useIcons, quark, recent_files);
+        }
+
+        menu_copy->append_item(menu_item);
+    }
+}
+
+/*
+  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 :