feat: Allow toolbar icons to be modified (#1509)

plugins/builtin/romfs/lang/en_US.json

@@ -483,6 +483,9 @@
         "hex.builtin.setting.proxy.url.tooltip": "http(s):// or socks5:// (e.g., http://127.0.0.1:1080)",
         "hex.builtin.setting.shortcuts": "Shortcuts",
         "hex.builtin.setting.shortcuts.global": "Global Shortcuts",
+        "hex.builtin.setting.toolbar": "Toolbar",
+        "hex.builtin.setting.toolbar.description": "Add or remove menu options to the toolbar.",
+        "hex.builtin.setting.toolbar.icons": "Toolbar Icons",
         "hex.builtin.shortcut.next_provider": "Select next provider",
         "hex.builtin.shortcut.prev_provider": "Select previous provider",
         "hex.builtin.title_bar_button.debug_build": "Debug build",

plugins/builtin/source/content/main_menu_items.cpp

@@ -351,7 +351,7 @@ namespace hex::plugin::builtin {
         }, noRunningTasks);
 
         /* Open File */
-        ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.file", "hex.builtin.menu.file.open_file" }, ICON_VS_OPEN_PREVIEW, 1100, CTRLCMD + Keys::O, [] {
+        ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.file", "hex.builtin.menu.file.open_file" }, ICON_VS_FOLDER_OPENED, 1100, CTRLCMD + Keys::O, [] {
             RequestOpenWindow::post("Open File");
         }, noRunningTasks);
 

plugins/builtin/source/content/settings_entries.cpp

@@ -360,6 +360,247 @@ namespace hex::plugin::builtin {
             bool m_hasDuplicate = false;
         };
 
+        class ToolbarIconsWidget : public ContentRegistry::Settings::Widgets::Widget {
+        private:
+            struct MenuItemSorter {
+                bool operator()(const auto *a, const auto *b) const {
+                    return a->toolbarIndex < b->toolbarIndex;
+                }
+            };
+
+        public:
+            bool draw(const std::string &) override {
+                bool changed = false;
+
+                // Top level layout table
+                if (ImGui::BeginTable("##top_level", 2, ImGuiTableFlags_None, ImGui::GetContentRegionAvail())) {
+                    ImGui::TableSetupColumn("##left", ImGuiTableColumnFlags_WidthStretch, 0.3F);
+                    ImGui::TableSetupColumn("##right", ImGuiTableColumnFlags_WidthStretch, 0.7F);
+                    ImGui::TableNextRow();
+                    ImGui::TableNextColumn();
+
+                    // Draw list of menu items that can be added to the toolbar
+                    if (ImGui::BeginTable("##all_icons", 1, ImGuiTableFlags_BordersOuter | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY, ImVec2(0, 280_scaled))) {
+                        ImGui::TableNextRow();
+                        ImGui::TableNextColumn();
+
+                        // Loop over all available menu items
+                        for (auto &[priority, menuItem] : ContentRegistry::Interface::impl::getMenuItems()) {
+                            // Filter out items without icon, separators, submenus and items that are already in the toolbar
+
+                            if (menuItem.icon.glyph.empty())
+                                continue;
+
+                            const auto &unlocalizedName = menuItem.unlocalizedNames.back();
+                            if (menuItem.unlocalizedNames.size() > 2)
+                                continue;
+                            if (unlocalizedName.get() == ContentRegistry::Interface::impl::SeparatorValue)
+                                continue;
+                            if (unlocalizedName.get() == ContentRegistry::Interface::impl::SubMenuValue)
+                                continue;
+                            if (menuItem.toolbarIndex != -1)
+                                continue;
+
+                            ImGui::TableNextRow();
+                            ImGui::TableNextColumn();
+
+                            // Draw the menu item
+                            ImGui::Selectable(hex::format("{} {}", menuItem.icon.glyph, Lang(unlocalizedName)).c_str(), false, ImGuiSelectableFlags_SpanAllColumns);
+
+                            // Handle draggin the menu item to the toolbar box
+                            if (ImGui::BeginDragDropSource()) {
+                                auto ptr = &menuItem;
+                                ImGui::SetDragDropPayload("MENU_ITEM_PAYLOAD", &ptr, sizeof(void*));
+
+                                ImGuiExt::TextFormatted("{} {}", menuItem.icon.glyph, Lang(unlocalizedName));
+
+                                ImGui::EndDragDropSource();
+                            }
+                        }
+
+                        ImGui::EndTable();
+                    }
+
+                    // Handle dropping menu items from the toolbar box
+                    if (ImGui::BeginDragDropTarget()) {
+                        if (auto payload = ImGui::AcceptDragDropPayload("TOOLBAR_ITEM_PAYLOAD"); payload != nullptr) {
+                            auto &menuItem = *static_cast<ContentRegistry::Interface::impl::MenuItem **>(payload->Data);
+
+                            menuItem->toolbarIndex = -1;
+                            changed = true;
+                        }
+
+                        ImGui::EndDragDropTarget();
+                    }
+
+                    ImGui::TableNextColumn();
+
+                    // Draw toolbar icon box
+                    ImGuiExt::BeginSubWindow("hex.builtin.setting.toolbar.icons"_lang, ImGui::GetContentRegionAvail());
+                    {
+                        if (ImGui::BeginTable("##icons", 6, ImGuiTableFlags_SizingStretchSame, ImGui::GetContentRegionAvail())) {
+                            ImGui::TableNextRow();
+
+                            // Find all menu items that are in the toolbar and sort them by their toolbar index
+                            std::set<ContentRegistry::Interface::impl::MenuItem*, MenuItemSorter> toolbarItems;
+                            for (auto &[priority, menuItem] : ContentRegistry::Interface::impl::getMenuItems()) {
+                                if (menuItem.toolbarIndex == -1)
+                                    continue;
+
+                                toolbarItems.emplace(&menuItem);
+                            }
+
+                            // Loop over all toolbar items
+                            for (auto &menuItem : toolbarItems) {
+                                // Filter out items without icon, separators, submenus and items that are not in the toolbar
+                                if (menuItem->icon.glyph.empty())
+                                    continue;
+
+                                const auto &unlocalizedName = menuItem->unlocalizedNames.back();
+                                if (menuItem->unlocalizedNames.size() > 2)
+                                    continue;
+                                if (unlocalizedName.get() == ContentRegistry::Interface::impl::SubMenuValue)
+                                    continue;
+                                if (menuItem->toolbarIndex == -1)
+                                    continue;
+
+                                ImGui::TableNextColumn();
+
+                                // Draw the toolbar item
+                                ImGui::InvisibleButton(unlocalizedName.get().c_str(), ImVec2(ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().x));
+
+                                // Handle dragging the toolbar item around
+                                if (ImGui::BeginDragDropSource()) {
+                                    ImGui::SetDragDropPayload("TOOLBAR_ITEM_PAYLOAD", &menuItem, sizeof(void*));
+
+                                    ImGuiExt::TextFormatted("{} {}", menuItem->icon.glyph, Lang(unlocalizedName));
+
+                                    ImGui::EndDragDropSource();
+                                }
+
+                                // Handle dropping toolbar items onto each other to reorder them
+                                if (ImGui::BeginDragDropTarget()) {
+                                    if (auto payload = ImGui::AcceptDragDropPayload("TOOLBAR_ITEM_PAYLOAD"); payload != nullptr) {
+                                        auto &otherMenuItem = *static_cast<ContentRegistry::Interface::impl::MenuItem **>(payload->Data);
+
+                                        std::swap(menuItem->toolbarIndex, otherMenuItem->toolbarIndex);
+                                        changed = true;
+                                    }
+
+                                    ImGui::EndDragDropTarget();
+                                }
+
+                                // Handle right clicking toolbar items to open the color selection popup
+                                if (ImGui::IsItemClicked(ImGuiMouseButton_Right))
+                                    ImGui::OpenPopup(unlocalizedName.get().c_str());
+
+                                // Draw the color selection popup
+                                if (ImGui::BeginPopup(unlocalizedName.get().c_str())) {
+                                    constexpr static std::array Colors = {
+                                        ImGuiCustomCol_ToolbarGray,
+                                        ImGuiCustomCol_ToolbarRed,
+                                        ImGuiCustomCol_ToolbarYellow,
+                                        ImGuiCustomCol_ToolbarGreen,
+                                        ImGuiCustomCol_ToolbarBlue,
+                                        ImGuiCustomCol_ToolbarPurple,
+                                        ImGuiCustomCol_ToolbarBrown
+                                    };
+
+                                    // Draw all the color buttons
+                                    for (auto color : Colors) {
+                                        ImGui::PushID(&color);
+                                        if (ImGui::ColorButton(hex::format("##color{}", u32(color)).c_str(), ImGuiExt::GetCustomColorVec4(color), ImGuiColorEditFlags_NoTooltip | ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker, ImVec2(20, 20))) {
+                                            menuItem->icon.color = color;
+                                            ImGui::CloseCurrentPopup();
+                                            changed = true;
+                                        }
+                                        ImGui::PopID();
+                                        ImGui::SameLine();
+                                    }
+
+                                    ImGui::EndPopup();
+                                }
+
+                                auto min = ImGui::GetItemRectMin();
+                                auto max = ImGui::GetItemRectMax();
+                                auto iconSize = ImGui::CalcTextSize(menuItem->icon.glyph.c_str());
+
+                                auto text = Lang(unlocalizedName).get();
+                                if (text.ends_with("..."))
+                                    text = text.substr(0, text.size() - 3);
+
+                                auto textSize = ImGui::CalcTextSize(text.c_str());
+
+                                // Draw icon and text of the toolbar item
+                                auto drawList = ImGui::GetWindowDrawList();
+                                drawList->AddText((min + ((max - min) - iconSize) / 2) - ImVec2(0, 10_scaled), ImGuiExt::GetCustomColorU32(ImGuiCustomCol(menuItem->icon.color)), menuItem->icon.glyph.c_str());
+                                drawList->AddText((min + ((max - min)) / 2) + ImVec2(-textSize.x / 2, 5_scaled), ImGui::GetColorU32(ImGuiCol_Text), text.c_str());
+                            }
+
+                            ImGui::EndTable();
+                        }
+                    }
+                    ImGuiExt::EndSubWindow();
+
+                    // Handle dropping menu items onto the toolbar box
+                    if (ImGui::BeginDragDropTarget()) {
+                        if (auto payload = ImGui::AcceptDragDropPayload("MENU_ITEM_PAYLOAD"); payload != nullptr) {
+                            auto &menuItem = *static_cast<ContentRegistry::Interface::impl::MenuItem **>(payload->Data);
+
+                            menuItem->toolbarIndex = m_currIndex;
+                            m_currIndex += 1;
+                            changed = true;
+                        }
+
+                        ImGui::EndDragDropTarget();
+                    }
+
+                    ImGui::EndTable();
+                }
+
+                return changed;
+            }
+
+            nlohmann::json store() override {
+                std::map<i32, std::pair<std::string, u32>> items;
+
+                for (const auto &[priority, menuItem] : ContentRegistry::Interface::impl::getMenuItems()) {
+                    if (menuItem.toolbarIndex != -1)
+                        items.emplace(menuItem.toolbarIndex, std::make_pair(menuItem.unlocalizedNames.back().get(), menuItem.icon.color));
+                }
+
+                return items;
+            }
+
+            void load(const nlohmann::json &data) override {
+                if (data.is_null())
+                    return;
+
+                auto toolbarItems = data.get<std::map<i32, std::pair<std::string, u32>>>();
+                if (toolbarItems.empty())
+                    return;
+
+                for (auto &[priority, menuItem] : ContentRegistry::Interface::impl::getMenuItems())
+                    menuItem.toolbarIndex = -1;
+
+                for (auto &[priority, menuItem] : ContentRegistry::Interface::impl::getMenuItems()) {
+                    for (const auto &[index, value] : toolbarItems) {
+                        const auto &[name, color] = value;
+                        if (menuItem.unlocalizedNames.back().get() == name) {
+                            menuItem.toolbarIndex = index;
+                            menuItem.icon.color   = ImGuiCustomCol(color);
+                            break;
+                        }
+                    }
+                }
+
+                m_currIndex = toolbarItems.size();
+            }
+
+        private:
+            i32 m_currIndex = 0;
+        };
+
     }
 
     void registerSettings() {
@@ -536,6 +777,11 @@ namespace hex::plugin::builtin {
             }
        });
 
+       /* Toolbar icons */
+        ContentRegistry::Settings::setCategoryDescription("hex.builtin.setting.toolbar", "hex.builtin.setting.toolbar.description");
+
+       ContentRegistry::Settings::add<ToolbarIconsWidget>("hex.builtin.setting.toolbar", "", "hex.builtin.setting.toolbar.icons");
+
     }
 
     static void loadLayoutSettings() {

plugins/builtin/source/content/ui_items.cpp

@@ -233,6 +233,12 @@ namespace hex::plugin::builtin {
         }
     }
 
+    struct MenuItemSorter {
+        bool operator()(const auto *a, const auto *b) const {
+            return a->toolbarIndex < b->toolbarIndex;
+        }
+    };
+
     void addToolbarItems() {
         ShortcutManager::addGlobalShortcut(AllowWhileTyping + ALT + CTRLCMD + Keys::Left, "hex.builtin.shortcut.prev_provider", []{
             auto currIndex = ImHexApi::Provider::getCurrentProviderIndex();
@@ -274,87 +280,39 @@ namespace hex::plugin::builtin {
         });
 
         ContentRegistry::Interface::addToolbarItem([] {
-            auto provider      = ImHexApi::Provider::get();
-            bool providerValid = provider != nullptr;
-            bool tasksRunning  = TaskManager::getRunningTaskCount() > 0;
+            std::set<const ContentRegistry::Interface::impl::MenuItem*, MenuItemSorter> menuItems;
 
-            // Undo
-            ImGui::BeginDisabled(!providerValid || !provider->canUndo());
-            {
-                if (ImGuiExt::ToolBarButton(ICON_VS_DISCARD, ImGuiExt::GetCustomColorVec4(ImGuiCustomCol_ToolbarBlue)))
-                    provider->undo();
-            }
-            ImGui::EndDisabled();
-
-            // Redo
-            ImGui::BeginDisabled(!providerValid || !provider->canRedo());
-            {
-                if (ImGuiExt::ToolBarButton(ICON_VS_REDO, ImGuiExt::GetCustomColorVec4(ImGuiCustomCol_ToolbarBlue)))
-                    provider->redo();
-            }
-            ImGui::EndDisabled();
-
-            ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
-
-            ImGui::BeginDisabled(tasksRunning);
-            {
-                // Create new file
-                if (ImGuiExt::ToolBarButton(ICON_VS_FILE, ImGuiExt::GetCustomColorVec4(ImGuiCustomCol_ToolbarGray))) {
-                    auto newProvider = hex::ImHexApi::Provider::createProvider("hex.builtin.provider.mem_file", true);
-                    if (newProvider != nullptr && !newProvider->open())
-                        hex::ImHexApi::Provider::remove(newProvider);
-                    else
-                        EventProviderOpened::post(newProvider);
-                }
-
-                // Open file
-                if (ImGuiExt::ToolBarButton(ICON_VS_FOLDER_OPENED, ImGuiExt::GetCustomColorVec4(ImGuiCustomCol_ToolbarBrown)))
-                    RequestOpenWindow::post("Open File");
-            }
-            ImGui::EndDisabled();
-
-            ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
-
-            // Save file
-            ImGui::BeginDisabled(!providerValid || !provider->isWritable() || !provider->isSavable());
-            {
-                if (ImGuiExt::ToolBarButton(ICON_VS_SAVE, ImGuiExt::GetCustomColorVec4(ImGuiCustomCol_ToolbarBlue)))
-                    provider->save();
-            }
-            ImGui::EndDisabled();
-
-            // Save file as
-            ImGui::BeginDisabled(!providerValid || !provider->isSavable());
-            {
-                if (ImGuiExt::ToolBarButton(ICON_VS_SAVE_AS, ImGuiExt::GetCustomColorVec4(ImGuiCustomCol_ToolbarBlue)))
-                    fs::openFileBrowser(fs::DialogMode::Save, {}, [&provider](auto path) {
-                        provider->saveAs(path);
-                    });
-            }
-            ImGui::EndDisabled();
-
-
-            ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
-
-
-            // Create bookmark
-            ImGui::BeginDisabled(!providerValid || !provider->isReadable() || !ImHexApi::HexEditor::isSelectionValid());
-            {
-                if (ImGuiExt::ToolBarButton(ICON_VS_BOOKMARK, ImGuiExt::GetCustomColorVec4(ImGuiCustomCol_ToolbarGreen))) {
-                    auto region = ImHexApi::HexEditor::getSelection();
-
-                    if (region.has_value())
-                        ImHexApi::Bookmarks::add(region->getStartAddress(), region->getSize(), {}, {});
+            for (const auto &[priority, menuItem] : ContentRegistry::Interface::impl::getMenuItems()) {
+                if (menuItem.toolbarIndex != -1) {
+                    menuItems.insert(&menuItem);
                 }
             }
-            ImGui::EndDisabled();
+
+            for (const auto &menuItem : menuItems) {
+                if (menuItem->unlocalizedNames.back().get() == ContentRegistry::Interface::impl::SeparatorValue) {
+                    ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
+                    continue;
+                }
+
+                ImGui::BeginDisabled(!menuItem->enabledCallback());
+                if (ImGuiExt::ToolBarButton(menuItem->icon.glyph.c_str(), ImGuiExt::GetCustomColorVec4(ImGuiCustomCol(menuItem->icon.color)))) {
+                    menuItem->callback();
+                }
+                ImGui::EndDisabled();
+            }
+        });
+
+        // Provider switcher
+        ContentRegistry::Interface::addToolbarItem([] {
+            const auto provider      = ImHexApi::Provider::get();
+            const bool providerValid = provider != nullptr;
+            const bool tasksRunning  = TaskManager::getRunningTaskCount() > 0;
 
             ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
             ImGui::Spacing();
             ImGui::Spacing();
             ImGui::Spacing();
 
-            // Provider switcher
             ImGui::BeginDisabled(!providerValid || tasksRunning);
             {
                 auto &providers = ImHexApi::Provider::getProviders();
@@ -446,6 +404,14 @@ namespace hex::plugin::builtin {
             }
             ImGui::EndDisabled();
         });
+
+        ContentRegistry::Interface::addMenuItemToToolbar("hex.builtin.menu.edit.undo", ImGuiCustomCol_ToolbarBlue);
+        ContentRegistry::Interface::addMenuItemToToolbar("hex.builtin.menu.edit.redo", ImGuiCustomCol_ToolbarBlue);
+        ContentRegistry::Interface::addMenuItemToToolbar("hex.builtin.menu.file.create_file", ImGuiCustomCol_ToolbarGray);
+        ContentRegistry::Interface::addMenuItemToToolbar("hex.builtin.menu.file.open_file", ImGuiCustomCol_ToolbarBrown);
+        ContentRegistry::Interface::addMenuItemToToolbar("hex.builtin.view.hex_editor.menu.file.save", ImGuiCustomCol_ToolbarBlue);
+        ContentRegistry::Interface::addMenuItemToToolbar("hex.builtin.view.hex_editor.menu.file.save_as", ImGuiCustomCol_ToolbarBlue);
+        ContentRegistry::Interface::addMenuItemToToolbar("hex.builtin.menu.edit.bookmark.create", ImGuiCustomCol_ToolbarGreen);
     }
 
     void handleBorderlessWindowMode() {

plugins/builtin/source/content/views/view_settings.cpp

@@ -24,10 +24,26 @@ namespace hex::plugin::builtin {
         ContentRegistry::Interface::addMenuItem({ "hex.builtin.menu.extras", "hex.builtin.view.settings.name" }, ICON_VS_SETTINGS_GEAR, 4000, Shortcut::None, [&, this] {
             this->getWindowOpenState() = true;
         });
+
+        EventImHexStartupFinished::subscribe(this, [] {
+            for (const auto &[unlocalizedCategory, unlocalizedDescription, subCategories] : ContentRegistry::Settings::impl::getSettings()) {
+                for (const auto &[unlocalizedSubCategory, entries] : subCategories) {
+                    for (const auto &[unlocalizedName, widget] : entries) {
+                        try {
+                            widget->load(ContentRegistry::Settings::impl::getSetting(unlocalizedCategory, unlocalizedName, widget->store()));
+                            widget->onChanged();
+                        } catch (const std::exception &e) {
+                            log::error("Failed to load setting [{} / {}]: {}", unlocalizedCategory.get(), unlocalizedName.get(), e.what());
+                        }
+                    }
+                }
+            }
+        });
     }
 
     ViewSettings::~ViewSettings() {
         RequestOpenWindow::unsubscribe(this);
+        EventImHexStartupFinished::unsubscribe(this);
     }
 
     void ViewSettings::drawContent() {

plugins/builtin/source/plugin_builtin.cpp

@@ -81,6 +81,8 @@ IMHEX_PLUGIN_SETUP("Built-in", "WerWolv", "Default ImHex functionality") {
     loadFonts();
     extractBundledFiles();
 
+    registerMainMenuEntries();
+
     registerEventHandlers();
     registerDataVisualizers();
     registerDataInspectorEntries();
@@ -114,7 +116,5 @@ IMHEX_PLUGIN_SETUP("Built-in", "WerWolv", "Default ImHex functionality") {
     addToolbarItems();
     addGlobalUIItems();
 
-    registerMainMenuEntries();
-
     handleBorderlessWindowMode();
 }