sys: Replaced Search view with a generic Find view

Closes #551

lib/libimhex/include/hex/providers/buffered_reader.hpp

@@ -9,10 +9,19 @@ namespace hex::prv {
 
     class BufferedReader {
     public:
-        explicit BufferedReader(Provider *provider, size_t bufferSize = 0xFF'FFFF) : m_provider(provider), m_maxBufferSize(bufferSize), m_buffer(bufferSize) { }
+        explicit BufferedReader(Provider *provider, size_t bufferSize = 0xFF'FFFF)
+        : m_provider(provider), m_bufferAddress(provider->getBaseAddress()), m_maxBufferSize(bufferSize),
+          m_startAddress(0x00), m_endAddress(provider->getActualSize()),
+          m_buffer(bufferSize) {
+
+        }
 
         void seek(u64 address) {
-            this->m_baseAddress = address;
+            this->m_startAddress = address;
+        }
+
+        void setEndAddress(u64 address) {
+            this->m_endAddress = address;
         }
 
         [[nodiscard]] std::vector<u8> read(u64 address, size_t size) {
@@ -27,7 +36,7 @@ namespace hex::prv {
 
             this->updateBuffer(address, size);
 
-            auto result = &this->m_buffer[address -  this->m_baseAddress];
+            auto result = &this->m_buffer[address -  this->m_bufferAddress];
 
             return { result, result + std::min(size, this->m_buffer.size()) };
         }
@@ -44,7 +53,7 @@ namespace hex::prv {
 
             this->updateBuffer(address - std::min<u64>(address, this->m_buffer.size()), size);
 
-            auto result = &this->m_buffer[address - this->m_baseAddress];
+            auto result = &this->m_buffer[address - this->m_startAddress];
 
             return { result, result + std::min(size, this->m_buffer.size()) };
         }
@@ -192,15 +201,15 @@ namespace hex::prv {
         };
 
         Iterator begin() {
-            return { this, this->m_baseAddress };
+            return { this, this->m_startAddress };
         }
 
         Iterator end() {
-            return { this, this->m_provider->getActualSize() };
+            return { this, this->m_endAddress };
         }
 
         ReverseIterator rbegin() {
-            return { this, this->m_baseAddress };
+            return { this, this->m_startAddress };
         }
 
         ReverseIterator rend() {
@@ -209,13 +218,13 @@ namespace hex::prv {
 
     private:
         void updateBuffer(u64 address, size_t size) {
-            if (!this->m_bufferValid || address < this->m_baseAddress || address + size > (this->m_baseAddress + this->m_buffer.size())) {
-                const auto remainingBytes = this->m_provider->getActualSize() - address;
+            if (!this->m_bufferValid || address < this->m_bufferAddress || address + size > (this->m_bufferAddress + this->m_buffer.size())) {
+                const auto remainingBytes = this->m_endAddress - address;
                 if (remainingBytes < this->m_maxBufferSize)
                     this->m_buffer.resize(remainingBytes);
 
                 this->m_provider->read(address, this->m_buffer.data(), this->m_buffer.size());
-                this->m_baseAddress = address;
+                this->m_bufferAddress = address;
                 this->m_bufferValid = true;
             }
         }
@@ -223,9 +232,10 @@ namespace hex::prv {
     private:
         Provider *m_provider;
 
+        u64 m_bufferAddress = 0x00;
         size_t m_maxBufferSize;
         bool m_bufferValid = false;
-        u64 m_baseAddress = 0x00;
+        u64 m_startAddress = 0x00, m_endAddress;
         std::vector<u8> m_buffer;
     };
 

plugins/builtin/CMakeLists.txt

@@ -35,7 +35,6 @@ add_library(${PROJECT_NAME} SHARED
         source/content/views/view_information.cpp
         source/content/views/view_about.cpp
         source/content/views/view_tools.cpp
-        source/content/views/view_strings.cpp
         source/content/views/view_data_inspector.cpp
         source/content/views/view_disassembler.cpp
         source/content/views/view_bookmarks.cpp
@@ -48,6 +47,7 @@ add_library(${PROJECT_NAME} SHARED
         source/content/views/view_store.cpp
         source/content/views/view_diff.cpp
         source/content/views/view_provider_settings.cpp
+        source/content/views/view_find.cpp
 
 
         source/math_evaluator.cpp

plugins/builtin/include/content/views/view_find.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <imgui.h>
+#include <hex/ui/view.hpp>
+
+#include <atomic>
+#include <vector>
+
+namespace hex::plugin::builtin {
+
+    class ViewFind : public View {
+    public:
+        ViewFind();
+        ~ViewFind() override = default;
+
+        void drawContent() override;
+
+    private:
+
+        struct SearchSettings {
+            int range = 0;
+
+            enum class Mode : int {
+                Strings,
+                Sequence,
+                Regex
+            } mode = Mode::Strings;
+
+            struct Strings {
+                int minLength = 5;
+                enum class Type : int { ASCII = 0, UTF16LE = 1, UTF16BE = 2 } type = Type::ASCII;
+                bool nullTermination = false;
+
+                bool m_lowerCaseLetters = true;
+                bool m_upperCaseLetters = true;
+                bool m_numbers = true;
+                bool m_underscores = true;
+                bool m_symbols = true;
+                bool m_spaces = true;
+                bool m_lineFeeds = false;
+            } strings;
+
+            struct Bytes {
+                std::string sequence;
+            } bytes;
+
+            struct Regex {
+                std::string pattern;
+            } regex;
+        } m_searchSettings, m_decodeSettings;
+
+        std::map<prv::Provider*, std::vector<Region>> m_foundRegions, m_sortedRegions;
+        std::atomic<bool> m_searchRunning;
+        bool m_settingsValid = false;
+
+    private:
+        static std::vector<Region> searchStrings(prv::Provider *provider, Region searchRegion, SearchSettings::Strings settings);
+        static std::vector<Region> searchSequence(prv::Provider *provider, Region searchRegion, SearchSettings::Bytes settings);
+        static std::vector<Region> searchRegex(prv::Provider *provider, Region searchRegion, SearchSettings::Regex settings);
+
+        void runSearch();
+        std::string decodeValue(prv::Provider *provider, Region region);
+    };
+
+}

plugins/builtin/include/content/views/view_strings.hpp

@@ -1,39 +0,0 @@
-#pragma once
-
-#include <hex/ui/view.hpp>
-
-#include <cstdio>
-#include <string>
-
-namespace hex::plugin::builtin {
-
-    struct FoundString {
-        u64 offset;
-        size_t size;
-    };
-
-    class ViewStrings : public View {
-    public:
-        explicit ViewStrings();
-        ~ViewStrings() override;
-
-        void drawContent() override;
-
-    private:
-        bool m_searching      = false;
-        bool m_regex          = false;
-        bool m_pattern_parsed = true;
-
-        std::vector<FoundString> m_foundStrings;
-        std::vector<size_t> m_filterIndices;
-        int m_minimumLength = 5;
-        std::string m_filter;
-
-        std::string m_selectedString;
-        std::string m_demangledName;
-
-        void searchStrings();
-        void createStringContextMenu(const FoundString &foundString);
-    };
-
-}

plugins/builtin/source/content/layouts.cpp

@@ -28,7 +28,7 @@ namespace hex::plugin::builtin {
             openViewAndDockTo("hex.builtin.view.pattern_editor.name", utils);
             openViewAndDockTo("hex.builtin.view.hashes.name", utils);
             openViewAndDockTo("hex.builtin.view.data_information.name", utils);
-            openViewAndDockTo("hex.builtin.view.strings.name", utils);
+            openViewAndDockTo("hex.builtin.view.find.name", utils);
             openViewAndDockTo("hex.builtin.view.bookmarks.name", utils);
         });
     }

plugins/builtin/source/content/views.cpp

@@ -5,7 +5,6 @@
 #include "content/views/view_information.hpp"
 #include "content/views/view_about.hpp"
 #include "content/views/view_tools.hpp"
-#include "content/views/view_strings.hpp"
 #include "content/views/view_data_inspector.hpp"
 #include "content/views/view_disassembler.hpp"
 #include "content/views/view_bookmarks.hpp"
@@ -18,6 +17,7 @@
 #include "content/views/view_store.hpp"
 #include "content/views/view_diff.hpp"
 #include "content/views/view_provider_settings.hpp"
+#include "content/views/view_find.hpp"
 
 namespace hex::plugin::builtin {
 
@@ -28,7 +28,6 @@ namespace hex::plugin::builtin {
         ContentRegistry::Views::add<ViewDataInspector>();
         ContentRegistry::Views::add<ViewHashes>();
         ContentRegistry::Views::add<ViewInformation>();
-        ContentRegistry::Views::add<ViewStrings>();
         ContentRegistry::Views::add<ViewDisassembler>();
         ContentRegistry::Views::add<ViewBookmarks>();
         ContentRegistry::Views::add<ViewPatches>();
@@ -42,6 +41,7 @@ namespace hex::plugin::builtin {
         ContentRegistry::Views::add<ViewStore>();
         ContentRegistry::Views::add<ViewDiff>();
         ContentRegistry::Views::add<ViewProviderSettings>();
+        ContentRegistry::Views::add<ViewFind>();
     }
 
 }

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

@@ -80,14 +80,14 @@ namespace hex::plugin::builtin {
 
                                 ImGui::TableNextRow();
                                 ImGui::TableNextColumn();
-                                ImGui::TextFormatted("Region: ");
+                                ImGui::TextFormatted("{}: ", "hex.builtin.common.region"_lang.get());
                                 ImGui::TableNextColumn();
                                 ImGui::TextFormatted("[ 0x{:08X} - 0x{:08X} ]", bookmark.region.getStartAddress(), bookmark.region.getEndAddress());
 
                                 if (!bookmark.comment.empty() && bookmark.comment[0] != '\x00') {
                                     ImGui::TableNextRow();
                                     ImGui::TableNextColumn();
-                                    ImGui::TextFormatted("Comment: ");
+                                    ImGui::TextFormatted("{}: ", "hex.builtin.view.bookmarks.header.comment"_lang.get());
                                     ImGui::TableNextColumn();
                                     ImGui::TextFormattedWrapped("\"{}\"", bookmark.comment);
                                 }
@@ -124,7 +124,7 @@ namespace hex::plugin::builtin {
         if (ImGui::Begin(View::toWindowName("hex.builtin.view.bookmarks.name").c_str(), &this->getWindowOpenState())) {
 
             ImGui::PushItemWidth(ImGui::GetContentRegionAvailWidth());
-            ImGui::InputTextWithHint("##filter", "Filter", this->m_currFilter);
+            ImGui::InputTextWithHint("##filter", "hex.builtin.common.filter"_lang, this->m_currFilter);
             ImGui::PopItemWidth();
 
             ImGui::NewLine();

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

@@ -0,0 +1,457 @@
+#include "content/views/view_find.hpp"
+
+#include <hex/api/imhex_api.hpp>
+#include <hex/providers/buffered_reader.hpp>
+
+#include <array>
+#include <regex>
+#include <string>
+#include <thread>
+#include <utility>
+
+#include <llvm/Demangle/Demangle.h>
+
+namespace hex::plugin::builtin {
+
+    ViewFind::ViewFind() : View("hex.builtin.view.find.name") {
+        const static auto HighlightColor = [] { return (ImGui::GetCustomColorU32(ImGuiCustomCol_ToolbarPurple) & 0x00FFFFFF) | 0x70000000; };
+
+        const static auto FindRegion = [this](u64 address) -> std::optional<Region> {
+            auto &regions = this->m_foundRegions[ImHexApi::Provider::get()];
+
+            auto it = std::upper_bound(regions.begin(), regions.end(), address, [](u64 address, Region &region) {
+                return address < region.getStartAddress();
+            });
+
+            if (it != regions.begin())
+                it--;
+
+            if (it != regions.end() && it->getStartAddress() <= address && address <= it->getEndAddress())
+                return *it;
+            else
+                return std::nullopt;
+        };
+
+        ImHexApi::HexEditor::addBackgroundHighlightingProvider([](u64 address, const u8* data, size_t size) -> std::optional<color_t> {
+            hex::unused(data, size);
+
+            if (FindRegion(address).has_value())
+                return HighlightColor();
+            else
+                return std::nullopt;
+        });
+
+        ImHexApi::HexEditor::addTooltipProvider([this](u64 address, const u8* data, size_t size) {
+            hex::unused(data, size);
+
+            auto region = FindRegion(address);
+            if (!region.has_value())
+                return;
+
+            ImGui::BeginTooltip();
+
+            ImGui::PushID(&region);
+            if (ImGui::BeginTable("##tooltips", 1, ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
+                ImGui::TableNextRow();
+                ImGui::TableNextColumn();
+
+                {
+                    const auto value = this->decodeValue(ImHexApi::Provider::get(), region.value());
+
+                    ImGui::ColorButton("##color", ImColor(HighlightColor()));
+                    ImGui::SameLine(0, 10);
+                    ImGui::TextFormatted("{}", value);
+
+                    if (ImGui::GetIO().KeyShift) {
+                        ImGui::Indent();
+                        if (ImGui::BeginTable("##extra_info", 2, ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
+
+                            ImGui::TableNextRow();
+                            ImGui::TableNextColumn();
+                            ImGui::TextFormatted("{}: ", "hex.builtin.common.region"_lang.get());
+                            ImGui::TableNextColumn();
+                            ImGui::TextFormatted("[ 0x{:08X} - 0x{:08X} ]", region->getStartAddress(), region->getEndAddress());
+
+                            auto demangledValue = llvm::demangle(value);
+
+                            if (value != demangledValue) {
+                                ImGui::TableNextRow();
+                                ImGui::TableNextColumn();
+                                ImGui::TextFormatted("{}: ", "hex.builtin.view.find.demangled"_lang.get());
+                                ImGui::TableNextColumn();
+                                ImGui::TextFormatted("{}", demangledValue);
+                            }
+
+                            ImGui::EndTable();
+                        }
+                        ImGui::Unindent();
+                    }
+                }
+
+
+                ImGui::PushStyleColor(ImGuiCol_TableRowBg, HighlightColor());
+                ImGui::PushStyleColor(ImGuiCol_TableRowBgAlt, HighlightColor());
+                ImGui::EndTable();
+                ImGui::PopStyleColor(2);
+            }
+            ImGui::PopID();
+
+            ImGui::EndTooltip();
+        });
+    }
+
+    std::vector<Region> ViewFind::searchStrings(prv::Provider *provider, hex::Region searchRegion, SearchSettings::Strings settings) {
+        std::vector<Region> results;
+
+        auto reader = prv::BufferedReader(provider);
+        reader.seek(searchRegion.getStartAddress());
+        reader.setEndAddress(searchRegion.getEndAddress());
+
+        size_t countedCharacters = 0;
+        u64 startAddress = reader.begin().getAddress();
+        for (u8 byte : reader) {
+            bool validChar =
+                (settings.m_lowerCaseLetters    && std::islower(byte))  ||
+                (settings.m_upperCaseLetters    && std::isupper(byte))  ||
+                (settings.m_numbers             && std::isdigit(byte))  ||
+                (settings.m_spaces              && std::isspace(byte))  ||
+                (settings.m_underscores         && byte == '_')             ||
+                (settings.m_symbols             && std::ispunct(byte))  ||
+                (settings.m_lineFeeds           && byte == '\n');
+
+            if (settings.type == SearchSettings::Strings::Type::UTF16LE) {
+                // Check if second byte of UTF-16 encoded string is 0x00
+                if (countedCharacters % 2 == 1)
+                    validChar =  byte == 0x00;
+            } else if (settings.type == SearchSettings::Strings::Type::UTF16BE) {
+                // Check if first byte of UTF-16 encoded string is 0x00
+                if (countedCharacters % 2 == 0)
+                    validChar =  byte == 0x00;
+            }
+
+            if (validChar)
+                countedCharacters++;
+            else {
+                if (countedCharacters >= size_t(settings.minLength)) {
+                    if (!(settings.nullTermination && byte != 0x00)) {
+                        results.push_back(Region { startAddress, countedCharacters });
+                    }
+                }
+
+                startAddress += countedCharacters + 1;
+                countedCharacters = 0;
+            }
+        }
+
+        return results;
+    }
+
+    std::vector<Region> ViewFind::searchSequence(prv::Provider *provider, hex::Region searchRegion, SearchSettings::Bytes settings) {
+        std::vector<Region> results;
+
+        auto reader = prv::BufferedReader(provider);
+        reader.seek(searchRegion.getStartAddress());
+        reader.setEndAddress(searchRegion.getEndAddress());
+
+        auto sequence = hex::decodeByteString(settings.sequence);
+        auto occurrence = reader.begin();
+        while (true) {
+            occurrence = std::search(reader.begin(), reader.end(), std::boyer_moore_horspool_searcher(sequence.begin(), sequence.end()));
+            if (occurrence == reader.end())
+                break;
+
+            reader.seek(occurrence.getAddress() + sequence.size());
+            results.push_back(Region { occurrence.getAddress(), sequence.size() });
+        }
+
+        return results;
+    }
+
+    std::vector<Region> ViewFind::searchRegex(prv::Provider *provider, hex::Region searchRegion, SearchSettings::Regex settings) {
+        auto stringRegions = searchStrings(provider, searchRegion, SearchSettings::Strings {
+            .minLength          = 1,
+            .type               = SearchSettings::Strings::Type::ASCII,
+            .m_lowerCaseLetters = true,
+            .m_upperCaseLetters = true,
+            .m_numbers          = true,
+            .m_underscores      = true,
+            .m_symbols          = true,
+            .m_spaces           = true,
+            .m_lineFeeds        = true
+        });
+
+        std::vector<Region> result;
+        std::regex regex(settings.pattern);
+        for (const auto &region : stringRegions) {
+            std::string string(region.getSize(), '\x00');
+            provider->read(region.getStartAddress(), string.data(), region.getSize());
+
+            if (std::regex_match(string, regex))
+                result.push_back(region);
+        }
+
+        return result;
+    }
+
+    void ViewFind::runSearch() {
+        Region searchRegion = [this]{
+            if (this->m_searchSettings.range == 0 || !ImHexApi::HexEditor::isSelectionValid()) {
+                auto provider = ImHexApi::Provider::get();
+                return Region { provider->getBaseAddress(), provider->getActualSize() };
+            } else {
+                return ImHexApi::HexEditor::getSelection().value();
+            }
+        }();
+
+        this->m_searchRunning = true;
+        std::thread([this, settings = this->m_searchSettings, searchRegion]{
+            auto task = ImHexApi::Tasks::createTask("hex.builtin.view.find.searching", 0);
+            auto provider = ImHexApi::Provider::get();
+
+            switch (settings.mode) {
+                using enum SearchSettings::Mode;
+                case Strings:
+                    this->m_foundRegions[provider] = searchStrings(provider, searchRegion, settings.strings);
+                    break;
+                case Sequence:
+                    this->m_foundRegions[provider] = searchSequence(provider, searchRegion, settings.bytes);
+                    break;
+                case Regex:
+                    this->m_foundRegions[provider] = searchRegex(provider, searchRegion, settings.regex);
+                    break;
+            }
+
+            this->m_sortedRegions = this->m_foundRegions;
+            this->m_searchRunning = false;
+        }).detach();
+    }
+
+    std::string ViewFind::decodeValue(prv::Provider *provider, hex::Region region) {
+        std::vector<u8> bytes(std::min<size_t>(region.getSize(), 128));
+        provider->read(region.getStartAddress(), bytes.data(), bytes.size());
+
+        std::string result;
+        switch (this->m_decodeSettings.mode) {
+            using enum SearchSettings::Mode;
+
+            case Strings:
+            {
+                auto &settings = this->m_decodeSettings.strings;
+
+                switch (settings.type) {
+                    using enum SearchSettings::Strings::Type;
+                    case ASCII:
+                        result = hex::encodeByteString(bytes);
+                        break;
+                    case UTF16LE:
+                        for (size_t i = 0; i < bytes.size(); i += 2)
+                            result += hex::encodeByteString({ bytes[i] });
+                        break;
+                    case UTF16BE:
+                        for (size_t i = 1; i < bytes.size(); i += 2)
+                            result += hex::encodeByteString({ bytes[i] });
+                        break;
+                }
+            }
+                break;
+            case Sequence:
+            case Regex:
+                result = hex::encodeByteString(bytes);
+                break;
+        }
+
+        return result;
+    }
+
+    static void drawContextMenu(const std::string &value) {
+        if (ImGui::IsMouseClicked(ImGuiMouseButton_Right) && ImGui::IsItemHovered()) {
+            ImGui::OpenPopup("FindContextMenu");
+        }
+
+        if (ImGui::BeginPopup("FindContextMenu")) {
+            if (ImGui::MenuItem("hex.builtin.view.find.context.copy"_lang)) {
+                ImGui::SetClipboardText(value.c_str());
+            if (ImGui::MenuItem("hex.builtin.view.find.context.copy_demangle"_lang))
+                ImGui::SetClipboardText(llvm::demangle(value).c_str());
+
+            ImGui::EndPopup();
+        }
+    }
+
+    void ViewFind::drawContent() {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.find.name").c_str(), &this->getWindowOpenState())) {
+
+            ImGui::BeginDisabled(this->m_searchRunning);
+            {
+                ImGui::Header("hex.builtin.view.find.range"_lang, true);
+                ImGui::RadioButton("hex.builtin.view.find.range.entire_data"_lang, &this->m_searchSettings.range, 0);
+                ImGui::RadioButton("hex.builtin.view.find.range.selection"_lang, &this->m_searchSettings.range, 1);
+
+                ImGui::NewLine();
+
+                if (ImGui::BeginTabBar("SearchMethods")) {
+                    auto &mode = this->m_searchSettings.mode;
+                    if (ImGui::BeginTabItem("hex.builtin.view.find.strings"_lang)) {
+                        auto &settings = this->m_searchSettings.strings;
+                        mode = SearchSettings::Mode::Strings;
+
+                        ImGui::InputInt("hex.builtin.view.find.strings.min_length"_lang, &settings.minLength, 1, 1);
+                        if (settings.minLength < 1)
+                            settings.minLength = 1;
+
+                        const std::array<std::string, 3> StringTypes = { "hex.builtin.common.encoding.ascii"_lang,"hex.builtin.common.encoding.utf16le"_lang, "hex.builtin.common.encoding.utf16be"_lang };
+                        if (ImGui::BeginCombo("hex.builtin.common.type"_lang, StringTypes[std::to_underlying(settings.type)].c_str())) {
+                            for (size_t i = 0; i < StringTypes.size(); i++) {
+                                auto type = static_cast<SearchSettings::Strings::Type>(i);
+
+                                if (ImGui::Selectable(StringTypes[i].c_str(), type == settings.type))
+                                    settings.type = type;
+                            }
+                            ImGui::EndCombo();
+                        }
+
+                        if (ImGui::CollapsingHeader("hex.builtin.view.find.strings.match_settings"_lang)) {
+                            ImGui::Checkbox("hex.builtin.view.find.strings.null_term"_lang, &settings.nullTermination);
+
+                            ImGui::Header("hex.builtin.view.find.strings.chars"_lang);
+                            ImGui::Checkbox(hex::format("{} [a-z]", "hex.builtin.view.find.strings.lower_case"_lang.get()).c_str(), &settings.m_lowerCaseLetters);
+                            ImGui::Checkbox(hex::format("{} [A-Z]", "hex.builtin.view.find.strings.upper_case"_lang.get()).c_str(), &settings.m_upperCaseLetters);
+                            ImGui::Checkbox(hex::format("{} [0-9]", "hex.builtin.view.find.strings.numbers"_lang.get()).c_str(), &settings.m_numbers);
+                            ImGui::Checkbox(hex::format("{} [_]", "hex.builtin.view.find.strings.underscores"_lang.get()).c_str(), &settings.m_underscores);
+                            ImGui::Checkbox(hex::format("{} [!\"#$%...]", "hex.builtin.view.find.strings.symbols"_lang.get()).c_str(), &settings.m_symbols);
+                            ImGui::Checkbox(hex::format("{} [ ]", "hex.builtin.view.find.strings.spaces"_lang.get()).c_str(), &settings.m_spaces);
+                            ImGui::Checkbox(hex::format("{} [\\n]", "hex.builtin.view.find.strings.line_feeds"_lang.get()).c_str(), &settings.m_lineFeeds);
+                        }
+
+                        this->m_settingsValid = true;
+
+                        ImGui::EndTabItem();
+                    }
+                    if (ImGui::BeginTabItem("hex.builtin.view.find.sequences"_lang)) {
+                        auto &settings = this->m_searchSettings.bytes;
+
+                        mode = SearchSettings::Mode::Sequence;
+
+                        ImGui::InputText("hex.builtin.common.value"_lang, settings.sequence);
+
+                        this->m_settingsValid = !settings.sequence.empty();
+
+                        ImGui::EndTabItem();
+                    }
+                    if (ImGui::BeginTabItem("hex.builtin.view.find.regex"_lang)) {
+                        auto &settings = this->m_searchSettings.regex;
+
+                        mode = SearchSettings::Mode::Regex;
+
+                        ImGui::InputText("hex.builtin.view.find.regex"_lang, settings.pattern);
+
+                        try {
+                            std::regex regex(settings.pattern);
+                            this->m_settingsValid = true;
+                        } catch (std::regex_error &e) {
+                            this->m_settingsValid = false;
+                        }
+
+                        if (settings.pattern.empty())
+                            this->m_settingsValid = false;
+
+                        ImGui::EndTabItem();
+                    }
+
+                    ImGui::EndTabBar();
+                }
+
+                ImGui::NewLine();
+
+                ImGui::BeginDisabled(!this->m_settingsValid);
+                {
+                    if (ImGui::Button("hex.builtin.view.find.search"_lang)) {
+                        this->runSearch();
+
+                        this->m_decodeSettings = this->m_searchSettings;
+                    }
+                }
+                ImGui::EndDisabled();
+
+            }
+            ImGui::EndDisabled();
+
+
+            ImGui::Separator();
+            ImGui::NewLine();
+
+            if (ImGui::BeginTable("##entries", 3, ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Sortable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
+                ImGui::TableSetupScrollFreeze(0, 1);
+                ImGui::TableSetupColumn("hex.builtin.common.offset"_lang, 0, -1, ImGui::GetID("offset"));
+                ImGui::TableSetupColumn("hex.builtin.common.size"_lang, 0, -1, ImGui::GetID("size"));
+                ImGui::TableSetupColumn("hex.builtin.common.value"_lang, 0, -1, ImGui::GetID("value"));
+
+                auto provider = ImHexApi::Provider::get();
+                auto &regions = this->m_sortedRegions[provider];
+
+                auto sortSpecs = ImGui::TableGetSortSpecs();
+
+                if (sortSpecs->SpecsDirty) {
+                    std::sort(regions.begin(), regions.end(), [this, &sortSpecs, provider](Region &left, Region &right) -> bool {
+                        if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("offset")) {
+                            if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
+                                return left.getStartAddress() > right.getStartAddress();
+                            else
+                                return left.getStartAddress() < right.getStartAddress();
+                        } else if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("size")) {
+                            if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
+                                return left.getSize() > right.getSize();
+                            else
+                                return left.getSize() < right.getSize();
+                        } else if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("value")) {
+                            if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
+                                return this->decodeValue(provider, left) > this->decodeValue(provider, right);
+                            else
+                                return this->decodeValue(provider, left) < this->decodeValue(provider, right);
+                        }
+
+                        return false;
+                    });
+
+                    sortSpecs->SpecsDirty = false;
+                }
+
+                ImGui::TableHeadersRow();
+
+                ImGuiListClipper clipper;
+                clipper.Begin(regions.size());
+
+                while (clipper.Step()) {
+                    for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++) {
+                        auto &foundItem = regions[i];
+
+                        ImGui::TableNextRow();
+                        ImGui::TableNextColumn();
+
+                        ImGui::TextFormatted("0x{:08X}", foundItem.getStartAddress());
+                        ImGui::TableNextColumn();
+                        ImGui::TextFormatted("{}", hex::toByteString(foundItem.getSize()));
+                        ImGui::TableNextColumn();
+
+                        ImGui::PushID(i);
+
+                        auto value = this->decodeValue(provider, foundItem);
+                        ImGui::TextFormatted("{}", value);
+                        ImGui::SameLine();
+                        if (ImGui::Selectable("##line", false, ImGuiSelectableFlags_SpanAllColumns))
+                            ImHexApi::HexEditor::setSelection(foundItem.getStartAddress(), foundItem.getSize());
+                        drawContextMenu(value);
+
+                        ImGui::PopID();
+                    }
+                }
+                clipper.End();
+
+                ImGui::EndTable();
+            }
+
+        }
+        ImGui::End();
+    }
+
+}

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

@@ -1,259 +0,0 @@
-#include "content/views/view_strings.hpp"
-
-#include <hex/providers/provider.hpp>
-#include <hex/helpers/fmt.hpp>
-
-#include <cstring>
-#include <thread>
-#include <regex>
-
-#include <llvm/Demangle/Demangle.h>
-#include <hex/ui/imgui_imhex_extensions.h>
-#include <imgui_internal.h>
-
-using namespace std::literals::string_literals;
-
-namespace hex::plugin::builtin {
-
-    ViewStrings::ViewStrings() : View("hex.builtin.view.strings.name") {
-        EventManager::subscribe<EventDataChanged>(this, [this]() {
-            this->m_foundStrings.clear();
-        });
-
-        this->m_filter.reserve(0xFFFF);
-        std::memset(this->m_filter.data(), 0x00, this->m_filter.capacity());
-
-        EventManager::subscribe<EventFileUnloaded>(this, [this] {
-            this->m_foundStrings.clear();
-        });
-    }
-
-    ViewStrings::~ViewStrings() {
-        EventManager::unsubscribe<EventDataChanged>(this);
-        EventManager::unsubscribe<EventFileUnloaded>(this);
-    }
-
-    std::string readString(const FoundString &foundString) {
-        std::string string(foundString.size + 1, '\0');
-        ImHexApi::Provider::get()->read(foundString.offset, string.data(), foundString.size);
-
-        return string;
-    }
-
-    void ViewStrings::createStringContextMenu(const FoundString &foundString) {
-        if (ImGui::TableGetColumnFlags(2) == ImGuiTableColumnFlags_IsHovered && ImGui::IsMouseReleased(1) && ImGui::IsItemHovered()) {
-            ImGui::OpenPopup("StringContextMenu");
-            this->m_selectedString = readString(foundString);
-        }
-        if (ImGui::BeginPopup("StringContextMenu")) {
-            if (ImGui::MenuItem("hex.builtin.view.strings.copy"_lang)) {
-                ImGui::SetClipboardText(this->m_selectedString.c_str());
-            }
-            ImGui::Separator();
-            if (ImGui::MenuItem("hex.builtin.view.strings.demangle"_lang)) {
-                this->m_demangledName = llvm::demangle(this->m_selectedString);
-                if (!this->m_demangledName.empty())
-                    ImHexApi::Tasks::doLater([] { ImGui::OpenPopup("hex.builtin.view.strings.demangle.name"_lang); });
-            }
-            ImGui::EndPopup();
-        }
-    }
-
-    void ViewStrings::searchStrings() {
-        this->m_foundStrings.clear();
-        this->m_filterIndices.clear();
-        this->m_searching = true;
-
-        std::thread([this] {
-            auto provider = ImHexApi::Provider::get();
-            auto task     = ImHexApi::Tasks::createTask("hex.builtin.view.strings.searching", provider->getActualSize());
-
-            std::vector<u8> buffer(1024, 0x00);
-            u32 foundCharacters = 0;
-
-            for (u64 offset = 0; offset < provider->getActualSize(); offset += buffer.size()) {
-                task.update(offset);
-
-                size_t readSize = std::min(u64(buffer.size()), provider->getActualSize() - offset);
-                provider->read(offset + provider->getBaseAddress(), buffer.data(), readSize);
-
-                for (u32 i = 0; i < readSize; i++) {
-                    if (buffer[i] >= ' ' && buffer[i] <= '~' && offset < provider->getActualSize() - 1)
-                        foundCharacters++;
-                    else {
-                        if (foundCharacters >= static_cast<u32>(this->m_minimumLength)) {
-                            FoundString foundString = {
-                                offset + i - foundCharacters + provider->getBaseAddress(),
-                                foundCharacters
-                            };
-
-                            this->m_foundStrings.push_back(foundString);
-                            this->m_filterIndices.push_back(this->m_foundStrings.size() - 1);
-                        }
-
-                        foundCharacters = 0;
-                    }
-                }
-            }
-
-            this->m_searching = false;
-        }).detach();
-    }
-
-    void ViewStrings::drawContent() {
-        auto provider = ImHexApi::Provider::get();
-
-        if (ImGui::Begin(View::toWindowName("hex.builtin.view.strings.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
-            if (ImHexApi::Provider::isValid() && provider->isReadable()) {
-                ImGui::BeginDisabled(this->m_searching);
-                {
-                    if (ImGui::InputInt("hex.builtin.view.strings.min_length"_lang, &this->m_minimumLength, 1, 0))
-                        this->m_foundStrings.clear();
-
-                    if (this->m_minimumLength < 1)
-                        this->m_minimumLength = 1;
-
-                    ImGui::Checkbox("hex.builtin.view.strings.regex"_lang, &this->m_regex);
-
-                    bool filterError = this->m_regex && !this->m_pattern_parsed;
-                    if (filterError)
-                        ImGui::PushStyleColor(ImGuiCol_FrameBg, ImAlphaBlendColors(ImGui::GetColorU32(ImGuiCol_FrameBg), ImColor(1.0f, 0.2f, 0.2f, 0.5f)));
-
-                    ImGui::InputText(
-                        "hex.builtin.view.strings.filter"_lang, this->m_filter.data(), this->m_filter.size(), ImGuiInputTextFlags_CallbackEdit | ImGuiInputTextFlags_CallbackResize, [](ImGuiInputTextCallbackData *data) {
-                            auto &view = *static_cast<ViewStrings *>(data->UserData);
-
-                            if (data->EventFlag == ImGuiInputTextFlags_CallbackResize) {
-                                view.m_filter.resize(data->BufSize);
-                                data->Buf = view.m_filter.data();
-                            }
-
-                            if (data->EventFlag == ImGuiInputTextFlags_CallbackEdit) {
-                               view.m_filterIndices.clear();
-
-                               std::regex pattern;
-                               if (view.m_regex) {
-                                   try {
-                                       pattern               = std::regex(data->Buf);
-                                       view.m_pattern_parsed = true;
-                                   } catch (std::regex_error &e) {
-                                       view.m_pattern_parsed = false;
-                                   }
-                               }
-                               for (u64 i = 0; i < view.m_foundStrings.size(); i++) {
-                                   if (view.m_regex) {
-                                       if (view.m_pattern_parsed && std::regex_search(readString(view.m_foundStrings[i]), pattern))
-                                           view.m_filterIndices.push_back(i);
-                                   } else if (readString(view.m_foundStrings[i]).find(data->Buf) != std::string::npos) {
-                                       view.m_filterIndices.push_back(i);
-                                   }
-                               }
-                            }
-
-                            return 0;
-                        },
-                        this);
-
-                    if (filterError)
-                        ImGui::PopStyleColor();
-
-                    if (ImGui::Button("hex.builtin.view.strings.extract"_lang))
-                        this->searchStrings();
-                }
-                ImGui::EndDisabled();
-
-                if (this->m_searching) {
-                    ImGui::SameLine();
-                    ImGui::TextSpinner("hex.builtin.view.strings.searching"_lang);
-                } else if (!this->m_foundStrings.empty()) {
-                    ImGui::SameLine();
-                    ImGui::TextFormatted("hex.builtin.view.strings.results"_lang, this->m_filterIndices.size());
-                }
-
-
-                ImGui::Separator();
-                ImGui::NewLine();
-
-                if (ImGui::BeginTable("##strings", 3, ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Sortable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
-                    ImGui::TableSetupScrollFreeze(0, 1);
-                    ImGui::TableSetupColumn("hex.builtin.view.strings.offset"_lang, 0, -1, ImGui::GetID("offset"));
-                    ImGui::TableSetupColumn("hex.builtin.view.strings.size"_lang, 0, -1, ImGui::GetID("size"));
-                    ImGui::TableSetupColumn("hex.builtin.view.strings.string"_lang, 0, -1, ImGui::GetID("string"));
-
-                    auto sortSpecs = ImGui::TableGetSortSpecs();
-
-                    if (sortSpecs->SpecsDirty) {
-                        std::sort(this->m_foundStrings.begin(), this->m_foundStrings.end(), [&sortSpecs](FoundString &left, FoundString &right) -> bool {
-                            if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("offset")) {
-                                if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
-                                    return left.offset > right.offset;
-                                else
-                                    return left.offset < right.offset;
-                            } else if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("size")) {
-                                if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
-                                    return left.size > right.size;
-                                else
-                                    return left.size < right.size;
-                            } else if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("string")) {
-                                if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
-                                    return readString(left) > readString(right);
-                                else
-                                    return readString(left) < readString(right);
-                            }
-
-                            return false;
-                        });
-
-                        sortSpecs->SpecsDirty = false;
-                    }
-
-                    ImGui::TableHeadersRow();
-
-                    ImGuiListClipper clipper;
-                    clipper.Begin(this->m_filterIndices.size());
-
-                    while (clipper.Step()) {
-                        for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++) {
-                            auto &foundString = this->m_foundStrings[this->m_filterIndices[i]];
-                            auto string       = readString(foundString);
-
-                            ImGui::TableNextRow();
-                            ImGui::TableNextColumn();
-                            if (ImGui::Selectable(("##StringLine"s + std::to_string(i)).c_str(), false, ImGuiSelectableFlags_SpanAllColumns)) {
-                                ImHexApi::HexEditor::setSelection(foundString.offset, foundString.size);
-                            }
-                            ImGui::PushID(i + 1);
-                            createStringContextMenu(foundString);
-                            ImGui::PopID();
-                            ImGui::SameLine();
-                            ImGui::TextFormatted("0x{0:08X} : 0x{1:08X}", foundString.offset, foundString.offset + foundString.size);
-                            ImGui::TableNextColumn();
-                            ImGui::TextFormatted("0x{0:04X}", foundString.size);
-                            ImGui::TableNextColumn();
-
-                            ImGui::TextUnformatted(string.c_str());
-                        }
-                    }
-                    clipper.End();
-
-                    ImGui::EndTable();
-                }
-            }
-        }
-        ImGui::End();
-
-        if (ImGui::BeginPopup("hex.builtin.view.strings.demangle.title"_lang)) {
-            if (ImGui::BeginChild("##scrolling", ImVec2(500, 150))) {
-                ImGui::TextUnformatted("hex.builtin.view.strings.demangle.title"_lang);
-                ImGui::Separator();
-                ImGui::TextFormattedWrapped("{}", this->m_demangledName.c_str());
-                ImGui::NewLine();
-                if (ImGui::Button("hex.builtin.view.strings.demangle.copy"_lang))
-                    ImGui::SetClipboardText(this->m_demangledName.c_str());
-            }
-            ImGui::EndChild();
-            ImGui::EndPopup();
-        }
-    }
-
-}

plugins/builtin/source/lang/de_DE.cpp

@@ -81,6 +81,14 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.common.browse", "Druchsuchen..." },
                 { "hex.builtin.common.choose_file", "Datei auswählen" },
                 { "hex.builtin.common.processing", "Verarbeiten" },
+                { "hex.builtin.common.filter", "Filter" },
+                { "hex.builtin.common.value", "Wert" },
+                { "hex.builtin.common.offset", "Offset" },
+
+                { "hex.builtin.common.encoding.ascii", "ASCII" },
+                { "hex.builtin.common.encoding.utf16le", "UTF-16LE" },
+                { "hex.builtin.common.encoding.utf16be", "UTF-16BE" },
+                { "hex.builtin.common.encoding.utf8", "UTF-8" },
 
                 { "hex.builtin.popup.exit_application.title", "Applikation verlassen?" },
                 { "hex.builtin.popup.exit_application.desc", "Es wurden ungespeicherte Änderungen an diesem Projekt vorgenommen\nBist du sicher, dass du ImHex schliessen willst?" },
@@ -330,22 +338,6 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.settings.name", "Einstellungen" },
                     { "hex.builtin.view.settings.restart_question", "Eine Änderung die du gemacht hast benötigt einen neustart von ImHex. Möchtest du ImHex jetzt neu starten?" },
 
-                { "hex.builtin.view.strings.name", "Strings" },
-                    { "hex.builtin.view.strings.copy", "String kopieren" },
-                    { "hex.builtin.view.strings.demangle", "Demangle" },
-                    { "hex.builtin.view.strings.min_length", "Minimallänge" },
-                    { "hex.builtin.view.strings.regex", "Regex" },
-                    { "hex.builtin.view.strings.filter", "Filter" },
-                    { "hex.builtin.view.strings.extract", "Extrahieren" },
-                    { "hex.builtin.view.strings.regex_error", "Ungültiges Regex" },
-                    { "hex.builtin.view.strings.results", "{0} Ergebnisse" },
-                    { "hex.builtin.view.strings.searching", "Suchen..." },
-                    { "hex.builtin.view.strings.offset", "Offset" },
-                    { "hex.builtin.view.strings.size", "Grösse" },
-                    { "hex.builtin.view.strings.string", "String" },
-                    { "hex.builtin.view.strings.demangle.title", "Demangled Namen" },
-                    { "hex.builtin.view.strings.demangle.copy", "Kopieren" },
-
                 { "hex.builtin.view.tools.name", "Werkzeuge" },
 
                 { "hex.builtin.view.yara.name", "Yara Regeln" },
@@ -389,6 +381,30 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.provider_settings.name", "Provider Einstellungen" },
                     { "hex.builtin.view.provider_settings.load_popup", "Provider öffnen" },
 
+                { "hex.builtin.view.find.name", "Finden" },
+                    { "hex.builtin.view.find.searching", "Suchen..." },
+                    { "hex.builtin.view.find.demangled", "Demangled" },
+                    { "hex.builtin.view.find.range", "Bereich" },
+                    { "hex.builtin.view.find.range.entire_data", "Gesammte Daten" },
+                    { "hex.builtin.view.find.range.selection", "Selektion" },
+                    { "hex.builtin.view.find.strings", "Strings" },
+                        { "hex.builtin.view.find.strings.min_length", "Minimallänge" },
+                        { "hex.builtin.view.find.strings.match_settings", "Sucheinstellungen" },
+                        { "hex.builtin.view.find.strings.null_term", "Null-Terminierung" },
+                        { "hex.builtin.view.find.strings.chars", "Zeichen" },
+                        { "hex.builtin.view.find.strings.lower_case", "Kleinbuchstaben" },
+                        { "hex.builtin.view.find.strings.upper_case", "Grossbuchstaben" },
+                        { "hex.builtin.view.find.strings.numbers", "Zahlen" },
+                        { "hex.builtin.view.find.strings.underscores", "Unterstriche" },
+                        { "hex.builtin.view.find.strings.symbols", "Symbole" },
+                        { "hex.builtin.view.find.strings.spaces", "Leerzeichen" },
+                        { "hex.builtin.view.find.strings.line_feeds", "Line Feeds" },
+                    { "hex.builtin.view.find.sequences", "Sequenzen" },
+                    { "hex.builtin.view.find.regex", "Regex" },
+                    { "hex.builtin.view.find.search", "Suchen" },
+                    { "hex.builtin.view.find.context.copy", "Wert Kopieren" },
+                    { "hex.builtin.view.find.context.copy_demangle", "Demangled Wert Kopieren" },
+
                 { "hex.builtin.command.calc.desc", "Rechner" },
                 { "hex.builtin.command.cmd.desc", "Command" },
                 { "hex.builtin.command.cmd.result", "Command '{0}' ausführen" },

plugins/builtin/source/lang/en_US.cpp

@@ -82,6 +82,15 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.common.browse", "Browse..." },
                 { "hex.builtin.common.choose_file", "Choose file" },
                 { "hex.builtin.common.processing", "Processing" },
+                { "hex.builtin.common.filter", "Filter" },
+                { "hex.builtin.common.value", "Value" },
+                { "hex.builtin.common.type", "Type" },
+                { "hex.builtin.common.offset", "Offset" },
+
+                { "hex.builtin.common.encoding.ascii", "ASCII" },
+                { "hex.builtin.common.encoding.utf16le", "UTF-16LE" },
+                { "hex.builtin.common.encoding.utf16be", "UTF-16BE" },
+                { "hex.builtin.common.encoding.utf8", "UTF-8" },
 
                 { "hex.builtin.popup.exit_application.title", "Exit Application?" },
                 { "hex.builtin.popup.exit_application.desc", "You have unsaved changes made to your Project.\nAre you sure you want to exit?" },
@@ -332,22 +341,6 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.settings.name", "Settings" },
                     { "hex.builtin.view.settings.restart_question", "A change you made requires a restart of ImHex to take effect. Would you like to restart it now?" },
 
-                { "hex.builtin.view.strings.name", "Strings" },
-                    { "hex.builtin.view.strings.copy", "Copy string" },
-                    { "hex.builtin.view.strings.demangle", "Demangle" },
-                    { "hex.builtin.view.strings.min_length", "Minimum length" },
-                    { "hex.builtin.view.strings.regex", "Regex" },
-                    { "hex.builtin.view.strings.filter", "Filter" },
-                    { "hex.builtin.view.strings.extract", "Extract" },
-                    { "hex.builtin.view.strings.regex_error", "Invalid regex" },
-                    { "hex.builtin.view.strings.results", "Found {0} occurrences" },
-                    { "hex.builtin.view.strings.searching", "Searching..." },
-                    { "hex.builtin.view.strings.offset", "Offset" },
-                    { "hex.builtin.view.strings.size", "Size" },
-                    { "hex.builtin.view.strings.string", "String" },
-                    { "hex.builtin.view.strings.demangle.title", "Demangled name" },
-                    { "hex.builtin.view.strings.demangle.copy", "Copy" },
-
                 { "hex.builtin.view.tools.name", "Tools" },
 
                 { "hex.builtin.view.yara.name", "Yara Rules" },
@@ -392,6 +385,31 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.provider_settings.name", "Provider Settings" },
                     { "hex.builtin.view.provider_settings.load_popup", "Open Provider" },
 
+                { "hex.builtin.view.find.name", "Find" },
+                    { "hex.builtin.view.find.searching", "Searching..." },
+                    { "hex.builtin.view.find.demangled", "Demangled" },
+                    { "hex.builtin.view.find.range", "Range" },
+                    { "hex.builtin.view.find.range.entire_data", "Entire Data" },
+                    { "hex.builtin.view.find.range.selection", "Selection" },
+                    { "hex.builtin.view.find.strings", "Strings" },
+                        { "hex.builtin.view.find.strings.min_length", "Minimum length" },
+                        { "hex.builtin.view.find.strings.match_settings", "Match Settings" },
+                        { "hex.builtin.view.find.strings.null_term", "Require Null Termination" },
+                        { "hex.builtin.view.find.strings.chars", "Characters" },
+                        { "hex.builtin.view.find.strings.lower_case", "Lower case letters" },
+                        { "hex.builtin.view.find.strings.upper_case", "Upper case letters" },
+                        { "hex.builtin.view.find.strings.numbers", "Numbers" },
+                        { "hex.builtin.view.find.strings.underscores", "Underscores" },
+                        { "hex.builtin.view.find.strings.symbols", "Symbols" },
+                        { "hex.builtin.view.find.strings.spaces", "Spaces" },
+                        { "hex.builtin.view.find.strings.line_feeds", "Line Feeds" },
+                    { "hex.builtin.view.find.sequences", "Sequences" },
+                    { "hex.builtin.view.find.regex", "Regex" },
+                    { "hex.builtin.view.find.search", "Search" },
+                    { "hex.builtin.view.find.context.copy", "Copy Value" },
+                    { "hex.builtin.view.find.context.copy_demangle", "Copy Demangled Value" },
+
+
                 { "hex.builtin.command.calc.desc", "Calculator" },
                 { "hex.builtin.command.cmd.desc", "Command" },
                 { "hex.builtin.command.cmd.result", "Run command '{0}'" },

plugins/builtin/source/lang/it_IT.cpp

@@ -81,6 +81,14 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.common.browse", "Esplora..." },
                 { "hex.builtin.common.choose_file", "Scegli file" },
                 //{ "hex.builtin.common.processing", "Processing" },
+                //{ "hex.builtin.common.filter", "Filter" },
+                //{ "hex.builtin.common.value", "Value" },
+                { "hex.builtin.common.offset", "Offset" },
+
+                { "hex.builtin.common.encoding.ascii", "ASCII" },
+                { "hex.builtin.common.encoding.utf16le", "UTF-16LE" },
+                { "hex.builtin.common.encoding.utf16be", "UTF-16BE" },
+                { "hex.builtin.common.encoding.utf8", "UTF-8" },
 
                 { "hex.builtin.popup.exit_application.title", "Uscire dall'applicazione?" },
                 { "hex.builtin.popup.exit_application.desc", "Hai delle modifiche non salvate nel tuo progetto.\nSei sicuro di voler uscire?" },
@@ -334,20 +342,6 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.settings.name", "Impostazioni" },
                     //{ "hex.builtin.view.settings.restart_question", "A change you made requires a restart of ImHex to take effect. Would you like to restart it now?" },
 
-                { "hex.builtin.view.strings.name", "Stringhe" },
-                    { "hex.builtin.view.strings.copy", "Copia stringa" },
-                    { "hex.builtin.view.strings.demangle", "Demangle" },
-                    { "hex.builtin.view.strings.min_length", "Lunghezza minima" },
-                    //{ "hex.builtin.view.strings.regex", "Regex" },
-                    { "hex.builtin.view.strings.filter", "Filtro" },
-                    { "hex.builtin.view.strings.extract", "Estrai" },
-                    { "hex.builtin.view.strings.searching", "Sto cercando..." },
-                    { "hex.builtin.view.strings.offset", "Offset" },
-                    { "hex.builtin.view.strings.size", "Dimensione" },
-                    { "hex.builtin.view.strings.string", "Stringa" },
-                    { "hex.builtin.view.strings.demangle.title", "Nome Demangled" },
-                    { "hex.builtin.view.strings.demangle.copy", "Copia" },
-
                 { "hex.builtin.view.tools.name", "Strumenti" },
 
                 { "hex.builtin.view.yara.name", "Regole di Yara" },
@@ -390,6 +384,30 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.provider_settings.name", "Impostazioni Provider" },
                     { "hex.builtin.view.provider_settings.load_popup", "Apri Provider" },
 
+                //{ "hex.builtin.view.find.name", "Find" },
+                //    { "hex.builtin.view.find.searching", "Searching..." },
+                //    { "hex.builtin.view.find.demangled", "Demangled" },
+                //    { "hex.builtin.view.find.range", "Range" },
+                //    { "hex.builtin.view.find.range.entire_data", "Entire Data" },
+                //    { "hex.builtin.view.find.range.selection", "Selection" },
+                //    { "hex.builtin.view.find.strings", "Strings" },
+                //        { "hex.builtin.view.find.strings.min_length", "Minimum length" },
+                //        { "hex.builtin.view.find.strings.match_settings", "Match Settings" },
+                //        { "hex.builtin.view.find.strings.null_term", "Require Null Termination" },
+                //        { "hex.builtin.view.find.strings.chars", "Characters" },
+                //        { "hex.builtin.view.find.strings.lower_case", "Lower case letters" },
+                //        { "hex.builtin.view.find.strings.upper_case", "Upper case letters" },
+                //        { "hex.builtin.view.find.strings.numbers", "Numbers" },
+                //        { "hex.builtin.view.find.strings.underscores", "Underscores" },
+                //        { "hex.builtin.view.find.strings.symbols", "Symbols" },
+                //        { "hex.builtin.view.find.strings.spaces", "Spaces" },
+                //        { "hex.builtin.view.find.strings.line_feeds", "Line Feeds" },
+                //    { "hex.builtin.view.find.sequences", "Sequences" },
+                //    { "hex.builtin.view.find.regex", "Regex" },
+                //    { "hex.builtin.view.find.search", "Search" },
+                //    { "hex.builtin.view.find.context.copy", "Copy Value" },
+                //    { "hex.builtin.view.find.context.copy_demangle", "Copy Demangled Value" },
+
                 { "hex.builtin.command.calc.desc", "Calcolatrice" },
                 { "hex.builtin.command.cmd.desc", "Comando" },
                 { "hex.builtin.command.cmd.result", "Esegui comando '{0}'" },

plugins/builtin/source/lang/ja_JP.cpp

@@ -81,6 +81,14 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.common.browse", "ファイルを参照..." },
                 { "hex.builtin.common.choose_file", "ファイルを選択" },
                 // { "hex.builtin.common.processing", "Processing" },
+                //{ "hex.builtin.common.filter", "Filter" },
+                //{ "hex.builtin.common.value", "Value" },
+                { "hex.builtin.common.offset", "オフセット" },
+
+                { "hex.builtin.common.encoding.ascii", "ASCII" },
+                { "hex.builtin.common.encoding.utf16le", "UTF-16LE" },
+                { "hex.builtin.common.encoding.utf16be", "UTF-16BE" },
+                { "hex.builtin.common.encoding.utf8", "UTF-8" },
 
                 { "hex.builtin.popup.exit_application.title", "アプリケーションを終了しますか？" },
                 { "hex.builtin.popup.exit_application.desc", "プロジェクトに保存されていない変更があります。\n終了してもよろしいですか？" },
@@ -333,22 +341,6 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.settings.name", "設定" },
                     //{ "hex.builtin.view.settings.restart_question", "A change you made requires a restart of ImHex to take effect. Would you like to restart it now?" },
 
-                { "hex.builtin.view.strings.name", "文字列" },
-                    { "hex.builtin.view.strings.copy", "文字列をコピー" },
-                    { "hex.builtin.view.strings.demangle", "デマングル" },
-                    { "hex.builtin.view.strings.min_length", "最小の長さ" },
-                    //{ "hex.builtin.view.strings.regex", "Regex" },
-                    { "hex.builtin.view.strings.filter", "フィルタ" },
-                    { "hex.builtin.view.strings.extract", "抽出" },
-                    { "hex.builtin.view.strings.regex_error", "無効な正規表現" },
-                    { "hex.builtin.view.strings.results", "{0} 件見つかりました" },
-                    { "hex.builtin.view.strings.searching", "検索中..." },
-                    { "hex.builtin.view.strings.offset", "オフセット" },
-                    { "hex.builtin.view.strings.size", "サイズ" },
-                    { "hex.builtin.view.strings.string", "文字列" },
-                    { "hex.builtin.view.strings.demangle.title", "デマングルした名前" },
-                    { "hex.builtin.view.strings.demangle.copy", "コピー" },
-
                 { "hex.builtin.view.tools.name", "ツール" },
 
                 { "hex.builtin.view.yara.name", "Yaraルール" },
@@ -393,6 +385,30 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.provider_settings.name", "プロバイダ設定" },
                     { "hex.builtin.view.provider_settings.load_popup", "プロバイダを開く" },
 
+                //{ "hex.builtin.view.find.name", "Find" },
+                //    { "hex.builtin.view.find.searching", "Searching..." },
+                //    { "hex.builtin.view.find.demangled", "Demangled" },
+                //    { "hex.builtin.view.find.range", "Range" },
+                //    { "hex.builtin.view.find.range.entire_data", "Entire Data" },
+                //    { "hex.builtin.view.find.range.selection", "Selection" },
+                //    { "hex.builtin.view.find.strings", "Strings" },
+                //        { "hex.builtin.view.find.strings.min_length", "Minimum length" },
+                //        { "hex.builtin.view.find.strings.match_settings", "Match Settings" },
+                //        { "hex.builtin.view.find.strings.null_term", "Require Null Termination" },
+                //        { "hex.builtin.view.find.strings.chars", "Characters" },
+                //        { "hex.builtin.view.find.strings.lower_case", "Lower case letters" },
+                //        { "hex.builtin.view.find.strings.upper_case", "Upper case letters" },
+                //        { "hex.builtin.view.find.strings.numbers", "Numbers" },
+                //        { "hex.builtin.view.find.strings.underscores", "Underscores" },
+                //        { "hex.builtin.view.find.strings.symbols", "Symbols" },
+                //        { "hex.builtin.view.find.strings.spaces", "Spaces" },
+                //        { "hex.builtin.view.find.strings.line_feeds", "Line Feeds" },
+                //    { "hex.builtin.view.find.sequences", "Sequences" },
+                //    { "hex.builtin.view.find.regex", "Regex" },
+                //    { "hex.builtin.view.find.search", "Search" },
+                //    { "hex.builtin.view.find.context.copy", "Copy Value" },
+                //    { "hex.builtin.view.find.context.copy_demangle", "Copy Demangled Value" },
+
                 { "hex.builtin.command.calc.desc", "計算機" },
                 { "hex.builtin.command.cmd.desc", "コマンド" },
                 { "hex.builtin.command.cmd.result", "コマンド '{0}' を実行" },

plugins/builtin/source/lang/pt_BR.cpp

@@ -81,6 +81,14 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.common.browse", "Navegar..." },
                 { "hex.builtin.common.choose_file", "Escolher arquivo" },
                 { "hex.builtin.common.processing", "Processando" },
+                //{ "hex.builtin.common.filter", "Filter" },
+                //{ "hex.builtin.common.value", "Value" },
+                { "hex.builtin.common.offset", "Offset" },
+
+                { "hex.builtin.common.encoding.ascii", "ASCII" },
+                { "hex.builtin.common.encoding.utf16le", "UTF-16LE" },
+                { "hex.builtin.common.encoding.utf16be", "UTF-16BE" },
+                { "hex.builtin.common.encoding.utf8", "UTF-8" },
 
                 { "hex.builtin.popup.exit_application.title", "Sair da aplicação?" },
                 { "hex.builtin.popup.exit_application.desc", "Você tem alterações não salvas feitas em seu projeto.\nVocê tem certeza que quer sair?" },
@@ -330,22 +338,6 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.settings.name", "Configurações" },
                     { "hex.builtin.view.settings.restart_question", "Uma alteração que você fez requer uma reinicialização do ImHex para entrar em vigor. Deseja reiniciar agora?" },
 
-                { "hex.builtin.view.strings.name", "Strings" },
-                    { "hex.builtin.view.strings.copy", "Copiar string" },
-                    { "hex.builtin.view.strings.demangle", "Demangle" },
-                    { "hex.builtin.view.strings.min_length", "Comprimento mínimo" },
-                    //{ "hex.builtin.view.strings.regex", "Regex" },
-                    { "hex.builtin.view.strings.filter", "Filtro" },
-                    { "hex.builtin.view.strings.extract", "Extrair" },
-                    { "hex.builtin.view.strings.regex_error", "Invalid regex" },
-                    { "hex.builtin.view.strings.results", "Encontrado {0} ocorrências" },
-                    { "hex.builtin.view.strings.searching", "Procurando..." },
-                    { "hex.builtin.view.strings.offset", "Desvio" },
-                    { "hex.builtin.view.strings.size", "Tamanho" },
-                    { "hex.builtin.view.strings.string", "String" },
-                    { "hex.builtin.view.strings.demangle.title", "Nome Desmembrado" },
-                    { "hex.builtin.view.strings.demangle.copy", "Copiar" },
-
                 { "hex.builtin.view.tools.name", "Ferramentas" },
 
                 { "hex.builtin.view.yara.name", "Regras Yara" },
@@ -390,6 +382,30 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.provider_settings.name", "Configurações do provedor" },
                     { "hex.builtin.view.provider_settings.load_popup", "Abrir Provedor" },
 
+                //{ "hex.builtin.view.find.name", "Find" },
+                //    { "hex.builtin.view.find.searching", "Searching..." },
+                //    { "hex.builtin.view.find.demangled", "Demangled" },
+                //    { "hex.builtin.view.find.range", "Range" },
+                //    { "hex.builtin.view.find.range.entire_data", "Entire Data" },
+                //    { "hex.builtin.view.find.range.selection", "Selection" },
+                //    { "hex.builtin.view.find.strings", "Strings" },
+                //        { "hex.builtin.view.find.strings.min_length", "Minimum length" },
+                //        { "hex.builtin.view.find.strings.match_settings", "Match Settings" },
+                //        { "hex.builtin.view.find.strings.null_term", "Require Null Termination" },
+                //        { "hex.builtin.view.find.strings.chars", "Characters" },
+                //        { "hex.builtin.view.find.strings.lower_case", "Lower case letters" },
+                //        { "hex.builtin.view.find.strings.upper_case", "Upper case letters" },
+                //        { "hex.builtin.view.find.strings.numbers", "Numbers" },
+                //        { "hex.builtin.view.find.strings.underscores", "Underscores" },
+                //        { "hex.builtin.view.find.strings.symbols", "Symbols" },
+                //        { "hex.builtin.view.find.strings.spaces", "Spaces" },
+                //        { "hex.builtin.view.find.strings.line_feeds", "Line Feeds" },
+                //    { "hex.builtin.view.find.sequences", "Sequences" },
+                //    { "hex.builtin.view.find.regex", "Regex" },
+                //    { "hex.builtin.view.find.search", "Search" },
+                //    { "hex.builtin.view.find.context.copy", "Copy Value" },
+                //    { "hex.builtin.view.find.context.copy_demangle", "Copy Demangled Value" },
+
                 { "hex.builtin.command.calc.desc", "Calculadora" },
                 { "hex.builtin.command.cmd.desc", "Comando" },
                 { "hex.builtin.command.cmd.result", "Iniciar Comando '{0}'" },

plugins/builtin/source/lang/zh_CN.cpp

@@ -81,6 +81,14 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.common.browse", "浏览..." },
                 { "hex.builtin.common.choose_file", "选择文件" },
                 { "hex.builtin.common.processing", "处理" },
+                //{ "hex.builtin.common.filter", "Filter" },
+                //{ "hex.builtin.common.value", "Value" },
+                { "hex.builtin.common.offset", "偏移" },
+
+                { "hex.builtin.common.encoding.ascii", "ASCII" },
+                { "hex.builtin.common.encoding.utf16le", "UTF-16LE" },
+                { "hex.builtin.common.encoding.utf16be", "UTF-16BE" },
+                { "hex.builtin.common.encoding.utf8", "UTF-8" },
 
                 { "hex.builtin.popup.exit_application.title", "退出？" },
                 { "hex.builtin.popup.exit_application.desc", "工程还有未保存的更改。\n确定要退出吗？" },
@@ -334,24 +342,6 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.settings.name", "设置" },
                     { "hex.builtin.view.settings.restart_question", "一项更改需要重启 ImHex 以生效，您想要现在重启吗？" },
 
-                { "hex.builtin.view.strings.name", "字符串" },
-                    { "hex.builtin.view.strings.copy", "复制字符串" },
-                    { "hex.builtin.view.strings.demangle", "还原" },
-                    { "hex.builtin.view.strings.min_length", "最小长度" },
-                    { "hex.builtin.view.strings.regex", "使用正则表达式" },
-                    { "hex.builtin.view.strings.filter", "搜索内容" },
-                    { "hex.builtin.view.strings.extract", "搜索" },
-                    { "hex.builtin.view.strings.regex_error", "非法正则" },
-                    { "hex.builtin.view.strings.results", "找到 {0} 个结果" },
-                    { "hex.builtin.view.strings.filter", "过滤" },
-                    { "hex.builtin.view.strings.extract", "提取" },
-                    { "hex.builtin.view.strings.searching", "搜索中..." },
-                    { "hex.builtin.view.strings.offset", "偏移" },
-                    { "hex.builtin.view.strings.size", "大小" },
-                    { "hex.builtin.view.strings.string", "字符串" },
-                    { "hex.builtin.view.strings.demangle.title", "还原名" },
-                    { "hex.builtin.view.strings.demangle.copy", "复制" },
-
                 { "hex.builtin.view.tools.name", "工具" },
 
                 { "hex.builtin.view.yara.name", "Yara 规则" },
@@ -395,6 +385,30 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.provider_settings.name", "提供器设置" },
                     { "hex.builtin.view.provider_settings.load_popup", "打开提供器" },
 
+                //{ "hex.builtin.view.find.name", "Find" },
+                //    { "hex.builtin.view.find.searching", "Searching..." },
+                //    { "hex.builtin.view.find.demangled", "Demangled" },
+                //    { "hex.builtin.view.find.range", "Range" },
+                //    { "hex.builtin.view.find.range.entire_data", "Entire Data" },
+                //    { "hex.builtin.view.find.range.selection", "Selection" },
+                //    { "hex.builtin.view.find.strings", "Strings" },
+                //        { "hex.builtin.view.find.strings.min_length", "Minimum length" },
+                //        { "hex.builtin.view.find.strings.match_settings", "Match Settings" },
+                //        { "hex.builtin.view.find.strings.null_term", "Require Null Termination" },
+                //        { "hex.builtin.view.find.strings.chars", "Characters" },
+                //        { "hex.builtin.view.find.strings.lower_case", "Lower case letters" },
+                //        { "hex.builtin.view.find.strings.upper_case", "Upper case letters" },
+                //        { "hex.builtin.view.find.strings.numbers", "Numbers" },
+                //        { "hex.builtin.view.find.strings.underscores", "Underscores" },
+                //        { "hex.builtin.view.find.strings.symbols", "Symbols" },
+                //        { "hex.builtin.view.find.strings.spaces", "Spaces" },
+                //        { "hex.builtin.view.find.strings.line_feeds", "Line Feeds" },
+                //    { "hex.builtin.view.find.sequences", "Sequences" },
+                //    { "hex.builtin.view.find.regex", "Regex" },
+                //    { "hex.builtin.view.find.search", "Search" },
+                //    { "hex.builtin.view.find.context.copy", "Copy Value" },
+                //    { "hex.builtin.view.find.context.copy_demangle", "Copy Demangled Value" },
+
                 { "hex.builtin.command.calc.desc", "计算器" },
                 { "hex.builtin.command.cmd.desc", "指令" },
                 { "hex.builtin.command.cmd.result", "运行指令 '{0}'" },

plugins/builtin/source/lang/zh_TW.cpp

@@ -81,6 +81,14 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.common.browse", "瀏覽..." },
                 { "hex.builtin.common.choose_file", "選擇檔案" },
                 { "hex.builtin.common.processing", "正在處理" },
+                //{ "hex.builtin.common.filter", "Filter" },
+                //{ "hex.builtin.common.value", "Value" },
+                { "hex.builtin.common.offset", "位移" },
+
+                { "hex.builtin.common.encoding.ascii", "ASCII" },
+                { "hex.builtin.common.encoding.utf16le", "UTF-16LE" },
+                { "hex.builtin.common.encoding.utf16be", "UTF-16BE" },
+                { "hex.builtin.common.encoding.utf8", "UTF-8" },
 
                 { "hex.builtin.popup.exit_application.title", "離開應用程式？" },
                 { "hex.builtin.popup.exit_application.desc", "您的專案有未儲存的更動。\n您確定要離開嗎？" },
@@ -331,22 +339,6 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.settings.name", "設定" },
                     { "hex.builtin.view.settings.restart_question", "需要重啟 ImHex 方能使您所做的更動生效。您要現在重新啟動嗎？" },
 
-                { "hex.builtin.view.strings.name", "字串" },
-                    { "hex.builtin.view.strings.copy", "複製字串" },
-                    { "hex.builtin.view.strings.demangle", "Demangle" },
-                    { "hex.builtin.view.strings.min_length", "最小長度" },
-                    { "hex.builtin.view.strings.regex", "Regex" },
-                    { "hex.builtin.view.strings.filter", "Filter" },
-                    { "hex.builtin.view.strings.extract", "Extract" },
-                    { "hex.builtin.view.strings.regex_error", "Invalid regex" },
-                    { "hex.builtin.view.strings.results", "Found {0} occurrences" },
-                    { "hex.builtin.view.strings.searching", "Searching..." },
-                    { "hex.builtin.view.strings.offset", "位移" },
-                    { "hex.builtin.view.strings.size", "大小" },
-                    { "hex.builtin.view.strings.string", "字串" },
-                    { "hex.builtin.view.strings.demangle.title", "Demangled name" },
-                    { "hex.builtin.view.strings.demangle.copy", "複製" },
-
                 { "hex.builtin.view.tools.name", "工具" },
 
                 { "hex.builtin.view.yara.name", "Yara 規則" },
@@ -391,6 +383,30 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.view.provider_settings.name", "提供者設定" },
                     { "hex.builtin.view.provider_settings.load_popup", "開啟提供者" },
 
+                //{ "hex.builtin.view.find.name", "Find" },
+                //    { "hex.builtin.view.find.searching", "Searching..." },
+                //    { "hex.builtin.view.find.demangled", "Demangled" },
+                //    { "hex.builtin.view.find.range", "Range" },
+                //    { "hex.builtin.view.find.range.entire_data", "Entire Data" },
+                //    { "hex.builtin.view.find.range.selection", "Selection" },
+                //    { "hex.builtin.view.find.strings", "Strings" },
+                //        { "hex.builtin.view.find.strings.min_length", "Minimum length" },
+                //        { "hex.builtin.view.find.strings.match_settings", "Match Settings" },
+                //        { "hex.builtin.view.find.strings.null_term", "Require Null Termination" },
+                //        { "hex.builtin.view.find.strings.chars", "Characters" },
+                //        { "hex.builtin.view.find.strings.lower_case", "Lower case letters" },
+                //        { "hex.builtin.view.find.strings.upper_case", "Upper case letters" },
+                //        { "hex.builtin.view.find.strings.numbers", "Numbers" },
+                //        { "hex.builtin.view.find.strings.underscores", "Underscores" },
+                //        { "hex.builtin.view.find.strings.symbols", "Symbols" },
+                //        { "hex.builtin.view.find.strings.spaces", "Spaces" },
+                //        { "hex.builtin.view.find.strings.line_feeds", "Line Feeds" },
+                //    { "hex.builtin.view.find.sequences", "Sequences" },
+                //    { "hex.builtin.view.find.regex", "Regex" },
+                //    { "hex.builtin.view.find.search", "Search" },
+                //    { "hex.builtin.view.find.context.copy", "Copy Value" },
+                //    { "hex.builtin.view.find.context.copy_demangle", "Copy Demangled Value" },
+
                 { "hex.builtin.command.calc.desc", "計算機" },
                 { "hex.builtin.command.cmd.desc", "命令" },
                 { "hex.builtin.command.cmd.result", "執行命令 '{0}'" },