build: Bumped version to 1.18.2

Closes #519

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.16)
 
 # Updating the version here will update it throughout ImHex as well
-set(IMHEX_VERSION "1.18.0")
+set(IMHEX_VERSION "1.18.2")
 project(imhex VERSION ${IMHEX_VERSION})
 
 set(CMAKE_CXX_STANDARD 20)

lib/external/imgui/source/TextEditor.cpp

@@ -821,7 +821,7 @@ void TextEditor::Render() {
                     ImGui::Text("Error at line %d:", errorIt->first);
                     ImGui::PopStyleColor();
                     ImGui::Separator();
-                    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 0.2f, 1.0f));
+                    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.5f, 0.5f, 0.2f, 1.0f));
                     ImGui::Text("%s", errorIt->second.c_str());
                     ImGui::PopStyleColor();
                     ImGui::EndTooltip();

lib/libimhex/include/hex.hpp

@@ -3,46 +3,8 @@
 #include <cstdint>
 #include <cstddef>
 
+#include <hex/helpers/types.hpp>
 #include <hex/helpers/intrinsics.hpp>
 
 constexpr static const auto ImHexApiURL  = "https://api.werwolv.net/imhex";
 constexpr static const auto GitHubApiURL = "https://api.github.com/repos/WerWolv/ImHex";
-
-using u8   = std::uint8_t;
-using u16  = std::uint16_t;
-using u32  = std::uint32_t;
-using u64  = std::uint64_t;
-using u128 = __uint128_t;
-
-using i8   = std::int8_t;
-using i16  = std::int16_t;
-using i32  = std::int32_t;
-using i64  = std::int64_t;
-using i128 = __int128_t;
-
-using color_t = u32;
-
-namespace hex {
-
-    struct Region {
-        u64 address;
-        size_t size;
-
-        [[nodiscard]] constexpr bool isWithin(const Region &other) const {
-            return (this->address >= other.address) && ((this->address + this->size) <= (other.address + other.size));
-        }
-
-        [[nodiscard]] constexpr bool overlaps(const Region &other) const {
-            return ((this->address + this->size) >= other.address) && (this->address < (other.address + other.size));
-        }
-
-        [[nodiscard]] constexpr u64 getStartAddress() const {
-            return this->address;
-        }
-
-        [[nodiscard]] constexpr u64 getEndAddress() const {
-            return this->address + this->size - 1;
-        }
-    };
-
-}

lib/libimhex/include/hex/api/content_registry.hpp

@@ -421,6 +421,74 @@ namespace hex {
             }
 
         }
+
+        namespace Hashes {
+
+            class Hash {
+            public:
+                Hash(std::string name) : m_name(std::move(name)) {}
+
+                class Function {
+                public:
+                    using Callback = std::function<std::vector<u8>(const Region&, prv::Provider *)>;
+
+                    Function(const Hash *type, std::string name, Callback callback)
+                        : m_type(type), m_name(std::move(name)), m_callback(std::move(callback)) {
+
+                    }
+
+                    [[nodiscard]] const Hash *getType() const { return this->m_type; }
+                    [[nodiscard]] const std::string &getName() const { return this->m_name; }
+
+                    const std::vector<u8>& get(const Region& region, prv::Provider *provider) {
+                        if (this->m_cache.empty()) {
+                            this->m_cache = this->m_callback(region, provider);
+                        }
+
+                        return this->m_cache;
+                    }
+
+                    void reset() {
+                        this->m_cache.clear();
+                    }
+
+                private:
+                    const Hash *m_type;
+                    std::string m_name;
+                    Callback m_callback;
+
+                    std::vector<u8> m_cache;
+                };
+
+                virtual void draw() { }
+                [[nodiscard]] virtual Function create(std::string name) = 0;
+
+                [[nodiscard]] const std::string &getName() const {
+                    return this->m_name;
+                }
+
+            protected:
+                [[nodiscard]] Function create(const std::string &name, const Function::Callback &callback) const {
+                    return { this, name, callback };
+                }
+
+            private:
+                std::string m_name;
+            };
+
+            namespace impl {
+
+                std::vector<Hash*> &getHashes();
+
+                void add(Hash* hash);
+            }
+
+            template<typename T, typename ... Args>
+            void add(Args && ... args) {
+                impl::add(new T(std::forward<Args>(args)...));
+            }
+
+        }
     };
 
 }

lib/libimhex/include/hex/helpers/encoding_file.hpp

@@ -2,9 +2,19 @@
 
 #include <hex.hpp>
 
-#include <map>
-#include <string_view>
-#include <vector>
+// TODO: Workaround for weird issue picked up by GCC 12.1.0 and later. This seems like a compiler bug mentioned in https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98465
+#pragma GCC diagnostic push
+
+    #if (__GNUC__ >= 12)
+        #pragma GCC diagnostic ignored "-Wrestrict"
+        #pragma GCC diagnostic ignored "-Wstringop-overread"
+    #endif
+
+    #include <map>
+    #include <string_view>
+    #include <vector>
+
+#pragma GCC diagnostic pop
 
 #include <hex/helpers/fs.hpp>
 #include <hex/helpers/file.hpp>

lib/libimhex/include/hex/helpers/types.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+using u8   = std::uint8_t;
+using u16  = std::uint16_t;
+using u32  = std::uint32_t;
+using u64  = std::uint64_t;
+using u128 = __uint128_t;
+
+using i8   = std::int8_t;
+using i16  = std::int16_t;
+using i32  = std::int32_t;
+using i64  = std::int64_t;
+using i128 = __int128_t;
+
+using color_t = u32;
+
+namespace hex {
+
+    struct Region {
+        u64 address;
+        size_t size;
+
+        [[nodiscard]] constexpr bool isWithin(const Region &other) const {
+            return (this->getStartAddress() >= other.getStartAddress()) && (this->getEndAddress() <= other.getEndAddress());
+        }
+
+        [[nodiscard]] constexpr bool overlaps(const Region &other) const {
+            return (this->getEndAddress() >= other.getStartAddress()) && (this->getStartAddress() < other.getEndAddress());
+        }
+
+        [[nodiscard]] constexpr u64 getStartAddress() const {
+            return this->address;
+        }
+
+        [[nodiscard]] constexpr u64 getEndAddress() const {
+            return this->address + this->size - 1;
+        }
+
+        [[nodiscard]] constexpr size_t getSize() const {
+            return this->size;
+        }
+    };
+
+}

lib/libimhex/include/hex/helpers/utils.hpp

@@ -72,6 +72,18 @@ namespace hex {
         return (value ^ mask) - mask;
     }
 
+    template<hex::integral T>
+    constexpr inline T swapBitOrder(size_t numBits, T value) {
+        T result = 0x00;
+
+        for (size_t bit = 0; bit < numBits; bit++) {
+            result <<= 1;
+            result |= (value & (1 << bit)) != 0;
+        }
+
+        return result;
+    }
+
     template<class... Ts>
     struct overloaded : Ts... { using Ts::operator()...; };
     template<class... Ts>

lib/libimhex/include/hex/ui/imgui_imhex_extensions.h

@@ -74,7 +74,8 @@ namespace ImGui {
     bool ToolBarButton(const char *symbol, ImVec4 color);
     bool IconButton(const char *symbol, ImVec4 color, ImVec2 size_arg = ImVec2(0, 0));
 
-    bool InputIntegerPrefix(const char* label, const char *prefix, u64 *value, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
+    bool InputIntegerPrefix(const char* label, const char *prefix, void *value, ImGuiDataType type, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
+    bool InputHexadecimal(const char* label, u32 *value, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
     bool InputHexadecimal(const char* label, u64 *value, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
 
     inline bool HasSecondPassed() {
@@ -134,4 +135,6 @@ namespace ImGui {
     bool InputScalarCallback(const char* label, ImGuiDataType data_type, void* p_data, const char* format, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);
 
     void HideTooltip();
+
+    bool BitCheckbox(const char* label, bool* v);
 }

lib/libimhex/source/api/content_registry.cpp

@@ -538,7 +538,7 @@ namespace hex {
 
     namespace ContentRegistry::HexEditor {
 
-        const int DataVisualizer::TextInputFlags = ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_NoHorizontalScroll | ImGuiInputTextFlags_EnterReturnsTrue;
+        const int DataVisualizer::TextInputFlags = ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoHorizontalScroll;
 
         bool DataVisualizer::drawDefaultEditingTextBox(u64 address, const char *format, ImGuiDataType dataType, u8 *data, ImGuiInputTextFlags flags) const {
             struct UserData {
@@ -582,4 +582,18 @@ namespace hex {
 
     }
 
+    namespace ContentRegistry::Hashes {
+
+        std::vector<Hash *> &impl::getHashes() {
+            static std::vector<Hash *> hashes;
+
+            return hashes;
+        }
+
+        void impl::add(Hash *hash) {
+            getHashes().push_back(hash);
+        }
+
+    }
+
 }

lib/libimhex/source/helpers/utils.cpp

@@ -204,11 +204,15 @@ namespace hex {
     }
 
     std::vector<std::string> splitString(const std::string &string, const std::string &delimiter) {
-        size_t start = 0, end;
+        size_t start = 0, end = 0;
         std::string token;
         std::vector<std::string> res;
 
         while ((end = string.find(delimiter, start)) != std::string::npos) {
+            size_t size = end - start;
+            if (start + size > string.length())
+                break;
+
             token = string.substr(start, end - start);
             start = end + delimiter.length();
             res.push_back(token);

lib/libimhex/source/ui/imgui_imhex_extensions.cpp

@@ -19,7 +19,7 @@ namespace ImGui {
         if (data->EventFlag == ImGuiInputTextFlags_CallbackResize) {
             auto &string = *static_cast<std::string *>(data->UserData);
 
-            string.resize(data->BufSize);
+            string.resize(data->BufTextLen);
             data->Buf = string.data();
         }
 
@@ -487,7 +487,7 @@ namespace ImGui {
         return pressed;
     }
 
-    bool InputIntegerPrefix(const char *label, const char *prefix, u64 *value, ImGuiInputTextFlags flags) {
+    bool InputIntegerPrefix(const char *label, const char *prefix, void *value, ImGuiDataType type, ImGuiInputTextFlags flags) {
         auto window             = ImGui::GetCurrentWindow();
         const ImGuiID id        = window->GetID(label);
         const ImGuiStyle &style = GImGui->Style;
@@ -500,7 +500,7 @@ namespace ImGui {
         ImGui::SetCursorPosX(ImGui::GetCursorPosX() + frame_size.x);
 
         char buf[64];
-        DataTypeFormatString(buf, IM_ARRAYSIZE(buf), ImGuiDataType_U64, value, "%llX");
+        DataTypeFormatString(buf, IM_ARRAYSIZE(buf), type, value, "%llX");
 
         bool value_changed = false;
         if (InputTextEx(label, nullptr, buf, IM_ARRAYSIZE(buf), ImVec2(CalcItemWidth() - frame_size.x, label_size.y + style.FramePadding.y * 2.0f), flags))
@@ -519,8 +519,12 @@ namespace ImGui {
         return value_changed;
     }
 
+    bool InputHexadecimal(const char *label, u32 *value, ImGuiInputTextFlags flags) {
+        return InputIntegerPrefix(label, "0x", value, ImGuiDataType_U32, flags | ImGuiInputTextFlags_CharsHexadecimal);
+    }
+
     bool InputHexadecimal(const char *label, u64 *value, ImGuiInputTextFlags flags) {
-        return InputIntegerPrefix(label, "0x", value, flags | ImGuiInputTextFlags_CharsHexadecimal);
+        return InputIntegerPrefix(label, "0x", value, ImGuiDataType_U64, flags | ImGuiInputTextFlags_CharsHexadecimal);
     }
 
     void SmallProgressBar(float fraction, float yOffset) {
@@ -590,4 +594,47 @@ namespace ImGui {
         }
     }
 
+
+    bool BitCheckbox(const char* label, bool* v) {
+        ImGuiWindow* window = GetCurrentWindow();
+        if (window->SkipItems)
+            return false;
+
+        ImGuiContext& g = *GImGui;
+        const ImGuiStyle& style = g.Style;
+        const ImGuiID id = window->GetID(label);
+        const ImVec2 label_size = CalcTextSize(label, NULL, true);
+
+        const ImVec2 size = ImVec2(CalcTextSize("0").x + style.FramePadding.x * 2, GetFrameHeight());
+        const ImVec2 pos = window->DC.CursorPos;
+        const ImRect total_bb(pos, pos + size);
+        ItemSize(total_bb, style.FramePadding.y);
+        if (!ItemAdd(total_bb, id))
+        {
+            IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Checkable | (*v ? ImGuiItemStatusFlags_Checked : 0));
+            return false;
+        }
+
+        bool hovered, held;
+        bool pressed = ButtonBehavior(total_bb, id, &hovered, &held);
+        if (pressed)
+        {
+            *v = !(*v);
+            MarkItemEdited(id);
+        }
+
+        const ImRect check_bb(pos, pos + size);
+        RenderNavHighlight(total_bb, id);
+        RenderFrame(check_bb.Min, check_bb.Max, GetColorU32((held && hovered) ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg), true, style.FrameRounding);
+
+        RenderText(check_bb.Min + style.FramePadding, *v ? "1" : "0");
+
+        ImVec2 label_pos = ImVec2(check_bb.Max.x + style.ItemInnerSpacing.x, check_bb.Min.y + style.FramePadding.y);
+        if (label_size.x > 0.0f)
+            RenderText(label_pos, label);
+
+        IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Checkable | (*v ? ImGuiItemStatusFlags_Checked : 0));
+        return pressed;
+    }
+
 }

main/source/init/tasks.cpp

@@ -178,10 +178,6 @@ namespace hex::init {
         ImHexApi::HexEditor::impl::getForegroundHighlightingFunctions().clear();
         ImHexApi::HexEditor::impl::getTooltips().clear();
 
-        while (ImHexApi::Provider::isValid())
-            ImHexApi::Provider::remove(ImHexApi::Provider::get());
-        ContentRegistry::Provider::getEntries().clear();
-
         ContentRegistry::Settings::getEntries().clear();
         ContentRegistry::Settings::getSettingsData().clear();
 
@@ -217,6 +213,10 @@ namespace hex::init {
         ContentRegistry::DataFormatter::getEntries().clear();
         ContentRegistry::FileHandler::getEntries().clear();
 
+        while (ImHexApi::Provider::isValid())
+            ImHexApi::Provider::remove(ImHexApi::Provider::get());
+        ContentRegistry::Provider::getEntries().clear();
+
         return true;
     }
 

main/source/window/window.cpp

@@ -653,8 +653,9 @@ namespace hex {
 
         io.ConfigFlags |= ImGuiConfigFlags_DockingEnable | ImGuiConfigFlags_NavEnableKeyboard;
 
-        {
+        if (glfwGetPrimaryMonitor() != nullptr) {
             auto sessionType = hex::getEnvironmentVariable("XDG_SESSION_TYPE");
+
             if (!sessionType || !hex::containsIgnoreCase(*sessionType, "wayland"))
                 io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
         }

plugins/builtin/CMakeLists.txt

@@ -22,6 +22,7 @@ add_library(${PROJECT_NAME} SHARED
         source/content/welcome_screen.cpp
         source/content/data_visualizers.cpp
         source/content/events.cpp
+        source/content/hashes.cpp
 
         source/content/providers/file_provider.cpp
         source/content/providers/gdb_provider.cpp
@@ -57,6 +58,7 @@ add_library(${PROJECT_NAME} SHARED
         source/lang/it_IT.cpp
         source/lang/zh_CN.cpp
         source/lang/ja_JP.cpp
+        source/lang/pt_BR.cpp
 )
 
 # Add additional include directories here #

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

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <hex/api/content_registry.hpp>
+
 #include <hex/ui/view.hpp>
 
 #include <array>
@@ -16,35 +18,10 @@ namespace hex::plugin::builtin {
         void drawContent() override;
 
     private:
-        enum class HashFunctions
-        {
-            Crc8,
-            Crc16,
-            Crc32,
-            Md5,
-            Sha1,
-            Sha224,
-            Sha256,
-            Sha384,
-            Sha512
-        };
+        ContentRegistry::Hashes::Hash *m_selectedHash = nullptr;
+        std::string m_newHashName;
 
-        bool m_shouldInvalidate     = true;
-        int m_currHashFunction      = 0;
-        u64 m_hashRegion[2]         = { 0 };
-        bool m_shouldMatchSelection = false;
-
-        static constexpr std::array hashFunctionNames {
-            std::pair {HashFunctions::Crc8,    "CRC8"   },
-            std::pair { HashFunctions::Crc16,  "CRC16"  },
-            std::pair { HashFunctions::Crc32,  "CRC32"  },
-            std::pair { HashFunctions::Md5,    "MD5"    },
-            std::pair { HashFunctions::Sha1,   "SHA-1"  },
-            std::pair { HashFunctions::Sha224, "SHA-224"},
-            std::pair { HashFunctions::Sha256, "SHA-256"},
-            std::pair { HashFunctions::Sha384, "SHA-384"},
-            std::pair { HashFunctions::Sha512, "SHA-512"},
-        };
+        std::vector<ContentRegistry::Hashes::Hash::Function> m_hashFunctions;
     };
 
 }

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

@@ -66,6 +66,10 @@ namespace hex::plugin::builtin {
             this->m_shouldScrollToSelection = true;
         }
 
+        void jumpIfOffScreen() {
+            this->m_shouldJumpWhenOffScreen = true;
+        }
+
     public:
         class Popup {
         public:
@@ -105,6 +109,7 @@ namespace hex::plugin::builtin {
 
         bool m_shouldJumpToSelection = false;
         bool m_shouldScrollToSelection = false;
+        bool m_shouldJumpWhenOffScreen = false;
 
         bool m_selectionChanged = false;
         u64 m_selectionStart = InvalidSelection;

plugins/builtin/source/content/data_inspector.cpp

@@ -84,7 +84,7 @@ namespace hex::plugin::builtin {
             [](auto buffer, auto endian, auto style) {
                 hex::unused(endian, style);
 
-                std::string binary = hex::format("0b{:b}", buffer[0]);
+                std::string binary = hex::format("0b{:08b}", buffer[0]);
 
                 return [binary] {
                     ImGui::TextUnformatted(binary.c_str());

plugins/builtin/source/content/data_processor_nodes.cpp

@@ -777,7 +777,16 @@ namespace hex::plugin::builtin {
         NodeVisualizerDigram() : Node("hex.builtin.nodes.visualizer.digram.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input") }) { }
 
         void drawNode() override {
-            const auto viewSize = scaled({ 200, 200 });
+            drawDigram(scaled({ 200, 200 }));
+
+            if (ImGui::IsItemHovered()) {
+                ImGui::BeginTooltip();
+                drawDigram(scaled({ 600, 600 }));
+                ImGui::EndTooltip();
+            }
+        }
+
+        void drawDigram(const ImVec2 &viewSize) {
             ImGui::PushStyleColor(ImGuiCol_ChildBg, ImU32(ImColor(0, 0, 0)));
             if (ImGui::BeginChild("##visualizer", viewSize, true)) {
                 auto drawList = ImGui::GetWindowDrawList();
@@ -860,7 +869,15 @@ namespace hex::plugin::builtin {
         NodeVisualizerLayeredDistribution() : Node("hex.builtin.nodes.visualizer.layered_dist.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input") }) { }
 
         void drawNode() override {
-            const auto viewSize = scaled({ 200, 200 });
+            drawLayeredDistribution(scaled({ 200, 200 }));
+            if (ImGui::IsItemHovered()) {
+                ImGui::BeginTooltip();
+                drawLayeredDistribution(scaled({ 600, 600 }));
+                ImGui::EndTooltip();
+            }
+        }
+
+        void drawLayeredDistribution(const ImVec2 &viewSize) {
             ImGui::PushStyleColor(ImGuiCol_ChildBg, ImU32(ImColor(0, 0, 0)));
             if (ImGui::BeginChild("##visualizer", viewSize, true)) {
                 auto drawList = ImGui::GetWindowDrawList();
@@ -944,6 +961,11 @@ namespace hex::plugin::builtin {
 
         void drawNode() override {
             ImGui::Image(this->m_texture, scaled(ImVec2(this->m_texture.aspectRatio() * 200, 200)));
+            if (ImGui::IsItemHovered()) {
+                ImGui::BeginTooltip();
+                ImGui::Image(this->m_texture, scaled(ImVec2(this->m_texture.aspectRatio() * 600, 600)));
+                ImGui::EndTooltip();
+            }
         }
 
         void process() override {
@@ -964,8 +986,18 @@ namespace hex::plugin::builtin {
         NodeVisualizerByteDistribution() : Node("hex.builtin.nodes.visualizer.byte_distribution.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input") }) { }
 
         void drawNode() override {
+            drawPlot(scaled({ 400, 300 }));
+
+            if (ImGui::IsItemHovered()) {
+                ImGui::BeginTooltip();
+                drawPlot(scaled({ 700, 550 }));
+                ImGui::EndTooltip();
+            }
+        }
+
+        void drawPlot(const ImVec2 &viewSize) {
             ImPlot::SetNextPlotLimits(0, 256, 0.5, float(*std::max_element(this->m_counts.begin(), this->m_counts.end())) * 1.1F, ImGuiCond_Always);
-            if (ImPlot::BeginPlot("##distribution", "Address", "Count", scaled(ImVec2(400, 300)), ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect, ImPlotAxisFlags_Lock, ImPlotAxisFlags_Lock | ImPlotAxisFlags_LogScale, ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoTickLabels, ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoTickLabels)) {
+            if (ImPlot::BeginPlot("##distribution", "Address", "Count", viewSize, ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect, ImPlotAxisFlags_Lock, ImPlotAxisFlags_Lock | ImPlotAxisFlags_LogScale, ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoTickLabels, ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoTickLabels)) {
                 static auto x = [] {
                     std::array<ImU64, 256> result { 0 };
                     std::iota(result.begin(), result.end(), 0);

plugins/builtin/source/content/hashes.cpp

@@ -0,0 +1,140 @@
+#include <hex/api/content_registry.hpp>
+#include <hex/api/localization.hpp>
+#include <hex/helpers/crypto.hpp>
+
+#include <hex/ui/imgui_imhex_extensions.h>
+
+namespace hex::plugin::builtin {
+
+    class HashMD5 : public ContentRegistry::Hashes::Hash {
+    public:
+        HashMD5() : Hash("hex.builtin.hash.md5"_lang) {}
+
+        Function create(std::string name) override {
+            return Hash::create(name, [](const Region& region, prv::Provider *provider) -> std::vector<u8> {
+                auto array = crypt::md5(provider, region.address, region.size);
+
+                return { array.begin(), array.end() };
+            });
+        }
+    };
+
+    class HashSHA1 : public ContentRegistry::Hashes::Hash {
+    public:
+        HashSHA1() : Hash("hex.builtin.hash.sha1"_lang) {}
+
+        Function create(std::string name) override {
+            return Hash::create(name, [](const Region& region, prv::Provider *provider) -> std::vector<u8> {
+                auto array = crypt::sha1(provider, region.address, region.size);
+
+                return { array.begin(), array.end() };
+            });
+        }
+    };
+
+    class HashSHA224 : public ContentRegistry::Hashes::Hash {
+    public:
+        HashSHA224() : Hash("hex.builtin.hash.sha224"_lang) {}
+
+        Function create(std::string name) override {
+            return Hash::create(name, [](const Region& region, prv::Provider *provider) -> std::vector<u8> {
+                auto array = crypt::sha224(provider, region.address, region.size);
+
+                return { array.begin(), array.end() };
+            });
+        }
+    };
+
+    class HashSHA256 : public ContentRegistry::Hashes::Hash {
+    public:
+        HashSHA256() : Hash("hex.builtin.hash.sha256"_lang) {}
+
+        Function create(std::string name) override {
+            return Hash::create(name, [](const Region& region, prv::Provider *provider) -> std::vector<u8> {
+                auto array = crypt::sha256(provider, region.address, region.size);
+
+                return { array.begin(), array.end() };
+            });
+        }
+    };
+
+    class HashSHA384 : public ContentRegistry::Hashes::Hash {
+    public:
+        HashSHA384() : Hash("hex.builtin.hash.sha384"_lang) {}
+
+        Function create(std::string name) override {
+            return Hash::create(name, [](const Region& region, prv::Provider *provider) -> std::vector<u8> {
+                auto array = crypt::sha384(provider, region.address, region.size);
+
+                return { array.begin(), array.end() };
+            });
+        }
+    };
+
+    class HashSHA512 : public ContentRegistry::Hashes::Hash {
+    public:
+        HashSHA512() : Hash("hex.builtin.hash.sha512") {}
+
+        Function create(std::string name) override {
+            return Hash::create(name, [](const Region& region, prv::Provider *provider) -> std::vector<u8> {
+                auto array = crypt::sha512(provider, region.address, region.size);
+
+                return { array.begin(), array.end() };
+            });
+        }
+    };
+
+    template<typename T>
+    class HashCRC : public ContentRegistry::Hashes::Hash {
+    public:
+        using CRCFunction = T(*)(prv::Provider*&, u64, size_t, u32, u32, u32, bool, bool);
+        HashCRC(const std::string &name, const CRCFunction &crcFunction, u32 polynomial, u32 initialValue, u32 xorOut)
+            : Hash(name), m_crcFunction(crcFunction), m_polynomial(polynomial), m_initialValue(initialValue), m_xorOut(xorOut) {}
+
+        void draw() override {
+            ImGui::InputHexadecimal("hex.builtin.hash.crc.poly"_lang, &this->m_polynomial);
+            ImGui::InputHexadecimal("hex.builtin.hash.crc.iv"_lang, &this->m_initialValue);
+            ImGui::InputHexadecimal("hex.builtin.hash.crc.xor_out"_lang, &this->m_xorOut);
+
+            ImGui::NewLine();
+
+            ImGui::Checkbox("hex.builtin.hash.crc.refl_in"_lang, &this->m_reflectIn);
+            ImGui::Checkbox("hex.builtin.hash.crc.refl_out"_lang, &this->m_reflectOut);
+        }
+
+        Function create(std::string name) override {
+            return Hash::create(name, [hash = *this](const Region& region, prv::Provider *provider) -> std::vector<u8> {
+                auto result = hash.m_crcFunction(provider, region.address, region.size, hash.m_polynomial, hash.m_initialValue, hash.m_xorOut, hash.m_reflectIn, hash.m_reflectOut);
+
+                std::vector<u8> bytes(sizeof(result), 0x00);
+                std::memcpy(bytes.data(), &result, bytes.size());
+
+                return bytes;
+            });
+        }
+
+    private:
+        CRCFunction m_crcFunction;
+
+        u32 m_polynomial;
+        u32 m_initialValue;
+        u32 m_xorOut;
+        bool m_reflectIn = false, m_reflectOut = false;
+    };
+
+    void registerHashes() {
+        ContentRegistry::Hashes::add<HashMD5>();
+
+        ContentRegistry::Hashes::add<HashSHA1>();
+        ContentRegistry::Hashes::add<HashSHA224>();
+        ContentRegistry::Hashes::add<HashSHA256>();
+        ContentRegistry::Hashes::add<HashSHA384>();
+        ContentRegistry::Hashes::add<HashSHA512>();
+
+        ContentRegistry::Hashes::add<HashCRC<u16>>("hex.builtin.hash.crc8"_lang,  crypt::crc8,  0x07,        0x0000,      0x0000);
+        ContentRegistry::Hashes::add<HashCRC<u16>>("hex.builtin.hash.crc16"_lang, crypt::crc16, 0x8005,      0x0000,      0x0000);
+        ContentRegistry::Hashes::add<HashCRC<u32>>("hex.builtin.hash.crc32"_lang, crypt::crc32, 0x04C1'1DB7, 0xFFFF'FFFF, 0xFFFF'FFFF);
+
+    }
+
+}

plugins/builtin/source/content/main_menu_items.cpp

@@ -257,7 +257,7 @@ namespace hex::plugin::builtin {
             if (ImGui::MenuItem("hex.builtin.menu.edit.bookmark"_lang, nullptr, false, selection.has_value() && providerValid)) {
                 auto base = provider->getBaseAddress();
 
-                ImHexApi::Bookmarks::add(base + selection->getStartAddress(), selection->getEndAddress(), {}, {});
+                ImHexApi::Bookmarks::add(base + selection->getStartAddress(), selection->size, {}, {});
             }
         });
 

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

@@ -61,7 +61,7 @@ namespace hex::plugin::builtin {
 
                 ImGui::BeginTooltip();
 
-                if (ImGui::BeginTable("##tooltips", 1, ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
+                if (ImGui::BeginTable("##tooltips", 1, ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
                     ImGui::TableNextRow();
                     ImGui::TableNextColumn();
 
@@ -143,7 +143,7 @@ namespace hex::plugin::builtin {
                     ImGui::PushStyleColor(ImGuiCol_HeaderHovered, u32(hoverColor));
 
                     bool open = true;
-                    if (ImGui::CollapsingHeader(name.c_str(), &open)) {
+                    if (ImGui::CollapsingHeader(hex::format("{}###bookmark", name).c_str(), &open)) {
                         ImGui::TextUnformatted("hex.builtin.view.bookmarks.title.info"_lang);
                         ImGui::Separator();
                         ImGui::TextFormatted("hex.builtin.view.bookmarks.address"_lang, region.address, region.address + region.size - 1, region.size);

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

@@ -1,294 +1,180 @@
 #include "content/views/view_hashes.hpp"
 
-#include <hex/providers/provider.hpp>
 #include <hex/helpers/crypto.hpp>
 
 #include <vector>
 
-
 namespace hex::plugin::builtin {
 
     ViewHashes::ViewHashes() : View("hex.builtin.view.hashes.name") {
-        EventManager::subscribe<EventDataChanged>(this, [this]() {
-            this->m_shouldInvalidate = true;
+        EventManager::subscribe<EventRegionSelected>(this, [this](const Region &) {
+            for (auto &function : this->m_hashFunctions)
+                function.reset();
         });
 
-        EventManager::subscribe<EventRegionSelected>(this, [this](Region region) {
-            if (this->m_shouldMatchSelection) {
-                if (region.address == size_t(-1)) {
-                    this->m_hashRegion[0] = this->m_hashRegion[1] = 0;
-                } else {
-                    this->m_hashRegion[0] = region.address;
-                    this->m_hashRegion[1] = region.size;
+        ImHexApi::HexEditor::addTooltipProvider([this](u64 address, const u8 *data, size_t size) {
+            hex::unused(data);
+
+            auto selection = ImHexApi::HexEditor::getSelection();
+
+            if (ImGui::GetIO().KeyShift) {
+                if (!this->m_hashFunctions.empty() && selection.has_value() && selection->overlaps(Region { address, size })) {
+                    ImGui::BeginTooltip();
+
+                    if (ImGui::BeginTable("##tooltips", 1, ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
+                        ImGui::TableNextRow();
+                        ImGui::TableNextColumn();
+
+                        ImGui::TextUnformatted("hex.builtin.view.hashes.name"_lang);
+                        ImGui::Separator();
+
+                        ImGui::Indent();
+                        if (ImGui::BeginTable("##hashes_tooltip", 3, ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit)) {
+                            auto provider  = ImHexApi::Provider::get();
+                            for (auto &function : this->m_hashFunctions) {
+                                ImGui::TableNextRow();
+                                ImGui::TableNextColumn();
+                                ImGui::TextFormatted("{}", function.getName());
+
+                                ImGui::TableNextColumn();
+                                ImGui::TextFormatted("    ");
+
+                                ImGui::TableNextColumn();
+                                if (provider != nullptr)
+                                    ImGui::TextFormatted("{}", crypt::encode16(function.get(*selection, provider)));
+                            }
+
+                            ImGui::EndTable();
+                        }
+                        ImGui::Unindent();
+
+                        ImGui::EndTable();
+                    }
+
+                    ImGui::EndTooltip();
                 }
-                this->m_shouldInvalidate = true;
             }
         });
     }
 
     ViewHashes::~ViewHashes() {
-        EventManager::unsubscribe<EventDataChanged>(this);
         EventManager::unsubscribe<EventRegionSelected>(this);
     }
 
 
-    template<size_t Size>
-    static void formatBigHexInt(std::array<u8, Size> dataArray, char *buffer, size_t bufferSize) {
-        for (size_t i = 0; i < dataArray.size(); i++)
-            snprintf(buffer + 2 * i, bufferSize - 2 * i, "%02X", dataArray[i]);
-    }
-
     void ViewHashes::drawContent() {
+        const auto &hashes = ContentRegistry::Hashes::impl::getHashes();
+
+        if (this->m_selectedHash == nullptr && !hashes.empty()) {
+            this->m_selectedHash = hashes.front();
+        }
+
         if (ImGui::Begin(View::toWindowName("hex.builtin.view.hashes.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
-            if (ImGui::BeginChild("##scrolling", ImVec2(0, 0), false, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav)) {
+            if (ImGui::BeginCombo("hex.builtin.view.hashes.function"_lang, this->m_selectedHash != nullptr ? this->m_selectedHash->getName().c_str() : "")) {
 
-
-                auto provider = ImHexApi::Provider::get();
-                if (ImHexApi::Provider::isValid() && provider->isAvailable()) {
-
-                    ImGui::TextUnformatted("hex.builtin.common.region"_lang);
-                    ImGui::Separator();
-
-                    ImGui::InputScalarN("##nolabel", ImGuiDataType_U64, this->m_hashRegion, 2, nullptr, nullptr, "%08X", ImGuiInputTextFlags_CharsHexadecimal);
-                    if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                    ImGui::Checkbox("hex.builtin.common.match_selection"_lang, &this->m_shouldMatchSelection);
-                    if (ImGui::IsItemEdited()) {
-                        // Force execution of Region Selection Event
-                        ImHexApi::HexEditor::setSelection(0, 0);
-                        this->m_shouldInvalidate = true;
-                    }
-
-                    ImGui::NewLine();
-                    ImGui::TextUnformatted("hex.builtin.view.hashes.settings"_lang);
-                    ImGui::Separator();
-
-                    if (ImGui::BeginCombo("hex.builtin.view.hashes.function"_lang, hashFunctionNames[this->m_currHashFunction].second, 0)) {
-                        for (size_t i = 0; i < hashFunctionNames.size(); i++) {
-                            bool is_selected = (static_cast<size_t>(this->m_currHashFunction) == i);
-                            if (ImGui::Selectable(hashFunctionNames[i].second, is_selected))
-                                this->m_currHashFunction = i;
-                            if (is_selected)
-                                ImGui::SetItemDefaultFocus();    // Set the initial focus when opening the combo (scrolling + for keyboard navigation support in the upcoming navigation branch)
-                        }
-                        ImGui::EndCombo();
-                        this->m_shouldInvalidate = true;
-                    }
-
-                    size_t dataSize = provider->getSize();
-                    if (this->m_hashRegion[1] >= provider->getBaseAddress() + dataSize)
-                        this->m_hashRegion[1] = provider->getBaseAddress() + dataSize;
-
-
-                    switch (hashFunctionNames[this->m_currHashFunction].first) {
-                        case HashFunctions::Crc8:
-                            {
-                                static int polynomial = 0x07, init = 0x0000, xorout = 0x0000;
-                                static bool reflectIn = false, reflectOut = false;
-
-                                ImGui::InputInt("hex.builtin.view.hashes.iv"_lang, &init, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::InputInt("hex.builtin.view.hashes.xorout"_lang, &xorout, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::Checkbox("hex.builtin.common.reflectIn"_lang, &reflectIn);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::Checkbox("hex.builtin.common.reflectOut"_lang, &reflectOut);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::InputInt("hex.builtin.view.hashes.poly"_lang, &polynomial, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::NewLine();
-
-                                static u8 result = 0;
-
-                                if (this->m_shouldInvalidate)
-                                    result = crypt::crc8(provider, this->m_hashRegion[0], this->m_hashRegion[1], polynomial, init, xorout, reflectIn, reflectOut);
-
-                                char buffer[sizeof(result) * 2 + 1];
-                                snprintf(buffer, sizeof(buffer), "%02X", result);
-
-                                ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
-                                ImGui::Separator();
-                                ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
-                            }
-                            break;
-                        case HashFunctions::Crc16:
-                            {
-                                static int polynomial = 0x8005, init = 0x0000, xorout = 0x0000;
-                                static bool reflectIn = false, reflectOut = false;
-
-                                ImGui::InputInt("hex.builtin.view.hashes.iv"_lang, &init, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::InputInt("hex.builtin.view.hashes.xorout"_lang, &xorout, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::Checkbox("hex.builtin.common.reflectIn"_lang, &reflectIn);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::Checkbox("hex.builtin.common.reflectOut"_lang, &reflectOut);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::InputInt("hex.builtin.view.hashes.poly"_lang, &polynomial, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::NewLine();
-
-                                static u16 result = 0;
-
-                                if (this->m_shouldInvalidate)
-                                    result = crypt::crc16(provider, this->m_hashRegion[0], this->m_hashRegion[1], polynomial, init, xorout, reflectIn, reflectOut);
-
-                                char buffer[sizeof(result) * 2 + 1];
-                                snprintf(buffer, sizeof(buffer), "%04X", result);
-
-                                ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
-                                ImGui::Separator();
-                                ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
-                            }
-                            break;
-                        case HashFunctions::Crc32:
-                            {
-                                static int polynomial = 0x04C11DB7, init = 0xFFFFFFFF, xorout = 0xFFFFFFFF;
-                                static bool reflectIn = true, reflectOut = true;
-
-
-                                ImGui::InputInt("hex.builtin.view.hashes.iv"_lang, &init, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::InputInt("hex.builtin.view.hashes.xorout"_lang, &xorout, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::Checkbox("hex.builtin.common.reflectIn"_lang, &reflectIn);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::Checkbox("hex.builtin.common.reflectOut"_lang, &reflectOut);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::InputInt("hex.builtin.view.hashes.poly"_lang, &polynomial, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
-                                if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
-
-                                ImGui::NewLine();
-
-                                static u32 result = 0;
-
-                                if (this->m_shouldInvalidate)
-                                    result = crypt::crc32(provider, this->m_hashRegion[0], this->m_hashRegion[1], polynomial, init, xorout, reflectIn, reflectOut);
-
-                                char buffer[sizeof(result) * 2 + 1];
-                                snprintf(buffer, sizeof(buffer), "%08X", result);
-
-                                ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
-                                ImGui::Separator();
-                                ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
-                            }
-                            break;
-                        case HashFunctions::Md5:
-                            {
-                                static std::array<u8, 16> result = { 0 };
-
-                                if (this->m_shouldInvalidate)
-                                    result = crypt::md5(provider, this->m_hashRegion[0], this->m_hashRegion[1]);
-
-                                char buffer[sizeof(result) * 2 + 1];
-                                formatBigHexInt(result, buffer, sizeof(buffer));
-
-                                ImGui::NewLine();
-                                ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
-                                ImGui::Separator();
-                                ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
-                            }
-                            break;
-                        case HashFunctions::Sha1:
-                            {
-                                static std::array<u8, 20> result = { 0 };
-
-                                if (this->m_shouldInvalidate)
-                                    result = crypt::sha1(provider, this->m_hashRegion[0], this->m_hashRegion[1]);
-
-                                char buffer[sizeof(result) * 2 + 1];
-                                formatBigHexInt(result, buffer, sizeof(buffer));
-
-                                ImGui::NewLine();
-                                ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
-                                ImGui::Separator();
-                                ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
-                            }
-                            break;
-                        case HashFunctions::Sha224:
-                            {
-                                static std::array<u8, 28> result = { 0 };
-
-                                if (this->m_shouldInvalidate)
-                                    result = crypt::sha224(provider, this->m_hashRegion[0], this->m_hashRegion[1]);
-
-                                char buffer[sizeof(result) * 2 + 1];
-                                formatBigHexInt(result, buffer, sizeof(buffer));
-
-                                ImGui::NewLine();
-                                ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
-                                ImGui::Separator();
-                                ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
-                            }
-                            break;
-                        case HashFunctions::Sha256:
-                            {
-                                static std::array<u8, 32> result;
-
-                                if (this->m_shouldInvalidate)
-                                    result = crypt::sha256(provider, this->m_hashRegion[0], this->m_hashRegion[1]);
-
-                                char buffer[sizeof(result) * 2 + 1];
-                                formatBigHexInt(result, buffer, sizeof(buffer));
-
-                                ImGui::NewLine();
-                                ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
-                                ImGui::Separator();
-                                ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
-                            }
-                            break;
-                        case HashFunctions::Sha384:
-                            {
-                                static std::array<u8, 48> result;
-
-                                if (this->m_shouldInvalidate)
-                                    result = crypt::sha384(provider, this->m_hashRegion[0], this->m_hashRegion[1]);
-
-                                char buffer[sizeof(result) * 2 + 1];
-                                formatBigHexInt(result, buffer, sizeof(buffer));
-
-                                ImGui::NewLine();
-                                ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
-                                ImGui::Separator();
-                                ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
-                            }
-                            break;
-                        case HashFunctions::Sha512:
-                            {
-                                static std::array<u8, 64> result;
-
-                                if (this->m_shouldInvalidate)
-                                    result = crypt::sha512(provider, this->m_hashRegion[0], this->m_hashRegion[1]);
-
-                                char buffer[sizeof(result) * 2 + 1];
-                                formatBigHexInt(result, buffer, sizeof(buffer));
-
-                                ImGui::NewLine();
-                                ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
-                                ImGui::Separator();
-                                ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
-                            }
-                            break;
+                for (const auto hash : hashes) {
+                    if (ImGui::Selectable(hash->getName().c_str(), this->m_selectedHash == hash)) {
+                        this->m_selectedHash = hash;
+                        this->m_newHashName.clear();
                     }
                 }
 
-                this->m_shouldInvalidate = false;
+                ImGui::EndCombo();
+            }
+
+            if (this->m_newHashName.empty() && this->m_selectedHash != nullptr)
+                this->m_newHashName = hex::format("{} {}", this->m_selectedHash->getName(), static_cast<const char *>("hex.builtin.view.hashes.hash"_lang));
+
+            if (ImGui::BeginChild("##settings", ImVec2(ImGui::GetContentRegionAvailWidth(), 200_scaled), true)) {
+                if (this->m_selectedHash != nullptr) {
+                    auto startPos = ImGui::GetCursorPosY();
+                    this->m_selectedHash->draw();
+
+                    // Check if no elements have been added
+                    if (startPos == ImGui::GetCursorPosY()) {
+                        ImGui::TextFormattedCentered("hex.builtin.view.hashes.no_settings"_lang);
+                    }
+                }
             }
             ImGui::EndChild();
+
+            ImGui::NewLine();
+
+            ImGui::InputText("##Name", this->m_newHashName);
+            ImGui::SameLine();
+
+            ImGui::BeginDisabled(this->m_newHashName.empty() || this->m_selectedHash == nullptr);
+            if (ImGui::IconButton(ICON_VS_ADD, ImGui::GetStyleColorVec4(ImGuiCol_Text))) {
+                if (this->m_selectedHash != nullptr)
+                    this->m_hashFunctions.push_back(this->m_selectedHash->create(this->m_newHashName));
+            }
+            ImGui::EndDisabled();
+
+            if (ImGui::BeginTable("##hashes", 3, ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_Borders, ImVec2(ImGui::GetContentRegionAvailWidth(), ImGui::GetTextLineHeightWithSpacing() * 10))) {
+                ImGui::TableSetupColumn("hex.builtin.view.hashes.name"_lang);
+                ImGui::TableSetupColumn("hex.builtin.view.hashes.type"_lang);
+                ImGui::TableSetupColumn("hex.builtin.view.hashes.result"_lang, ImGuiTableColumnFlags_WidthStretch);
+
+                ImGui::TableHeadersRow();
+
+                auto provider  = ImHexApi::Provider::get();
+                auto selection = ImHexApi::HexEditor::getSelection();
+
+                std::optional<u32> indexToRemove;
+                for (u32 i = 0; i < this->m_hashFunctions.size(); i++) {
+                    auto &function = this->m_hashFunctions[i];
+
+                    ImGui::PushID(i);
+
+                    ImGui::TableNextRow();
+                    ImGui::TableNextColumn();
+
+                    ImGui::PushStyleColor(ImGuiCol_Header, 0x00);
+                    ImGui::PushStyleColor(ImGuiCol_HeaderActive, 0x00);
+                    ImGui::PushStyleColor(ImGuiCol_HeaderHovered, 0x00);
+                    ImGui::Selectable(function.getName().c_str(), false);
+                    ImGui::PopStyleColor(3);
+
+                    {
+                        const auto ContextMenuId = hex::format("Context Menu {}", i);
+
+                        if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Right))
+                            ImGui::OpenPopup(ContextMenuId.c_str());
+
+                        if (ImGui::BeginPopup(ContextMenuId.c_str())) {
+                            if (ImGui::MenuItem("hex.builtin.view.hashes.remove"_lang))
+                                indexToRemove = i;
+
+                            ImGui::EndPopup();
+                        }
+                    }
+
+                    ImGui::TableNextColumn();
+                    ImGui::TextFormatted("{}", function.getType()->getName());
+
+                    ImGui::TableNextColumn();
+                    std::string result;
+                    if (provider != nullptr && selection.has_value())
+                        result = crypt::encode16(function.get(*selection, provider));
+                    else
+                        result = "???";
+
+                    ImGui::PushItemWidth(ImGui::GetContentRegionAvailWidth());
+                    ImGui::InputText("##result", result, ImGuiInputTextFlags_ReadOnly);
+                    ImGui::PopItemWidth();
+
+                    ImGui::PopID();
+                }
+
+                if (indexToRemove.has_value()) {
+                    this->m_hashFunctions.erase(this->m_hashFunctions.begin() + indexToRemove.value());
+                }
+
+                ImGui::EndTable();
+            }
+
+            ImGui::NewLine();
+            ImGui::TextWrapped("%s", static_cast<const char *>("hex.builtin.view.hashes.hover_info"_lang));
         }
         ImGui::End();
     }

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

@@ -439,7 +439,7 @@ namespace hex::plugin::builtin {
             ImGui::BeginTooltip();
 
             for (const auto &[id, tooltip] : tooltips) {
-                if (ImGui::BeginTable("##tooltips", 1, ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
+                if (ImGui::BeginTable("##tooltips", 1, ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
                     ImGui::TableNextRow();
                     ImGui::TableNextColumn();
 
@@ -484,8 +484,9 @@ namespace hex::plugin::builtin {
             ImGui::SetKeyboardFocusHere();
             ImGui::CaptureKeyboardFromApp(true);
 
-            if (this->m_currDataVisualizer->drawEditing(address, this->m_editingBytes.data(), this->m_editingBytes.size(), this->m_upperCaseHex, this->m_enteredEditingMode) || this->m_shouldModifyValue) {
-                provider->write(address, this->m_editingBytes.data(), this->m_editingBytes.size());
+            if (this->m_currDataVisualizer->drawEditing(*this->m_editingAddress, this->m_editingBytes.data(), this->m_editingBytes.size(), this->m_upperCaseHex, this->m_enteredEditingMode) || this->m_shouldModifyValue) {
+
+                provider->write(*this->m_editingAddress, this->m_editingBytes.data(), this->m_editingBytes.size());
 
                 if (!this->m_selectionChanged && !ImGui::IsMouseDown(ImGuiMouseButton_Left) && !ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
                     auto nextEditingAddress = *this->m_editingAddress + this->m_currDataVisualizer->getBytesPerCell();
@@ -499,6 +500,9 @@ namespace hex::plugin::builtin {
                     this->m_editingAddress = std::nullopt;
                 }
 
+                this->m_editingBytes.resize(size);
+                std::memcpy(this->m_editingBytes.data(), data, size);
+
                 this->m_shouldModifyValue = false;
             }
 
@@ -845,7 +849,9 @@ namespace hex::plugin::builtin {
                             }
 
                             // If the cursor is off-screen, directly jump to the byte
-                            {
+                            if (this->m_shouldJumpWhenOffScreen) {
+                                this->m_shouldJumpWhenOffScreen = false;
+
                                 const auto newSelection = this->getSelection();
                                 if (newSelection.getStartAddress() < u64(clipper.DisplayStart * this->m_bytesPerRow))
                                     this->jumpToSelection();
@@ -1014,7 +1020,7 @@ namespace hex::plugin::builtin {
         if (clipboard.length() % 2 != 0) return;
 
         // Convert hex string to bytes
-        std::vector<u8> buffer = hex::decodeByteString(clipboard);
+        std::vector<u8> buffer = crypt::decode16(clipboard);
 
         // Write bytes
         provider->write(selection.getStartAddress() + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), std::min(selection.size, buffer.size()));
@@ -1059,24 +1065,28 @@ namespace hex::plugin::builtin {
                 auto pos = this->m_selectionEnd - this->m_bytesPerRow;
                 this->setSelection(pos, pos);
                 this->scrollToSelection();
+                this->jumpIfOffScreen();
             }
         });
         ShortcutManager::addShortcut(this, Keys::Down, [this] {
             auto pos = this->m_selectionEnd + this->m_bytesPerRow;
             this->setSelection(pos, pos);
             this->scrollToSelection();
+            this->jumpIfOffScreen();
         });
         ShortcutManager::addShortcut(this, Keys::Left, [this] {
             if (this->m_selectionEnd > 0) {
                 auto pos = this->m_selectionEnd - 1;
                 this->setSelection(pos, pos);
                 this->scrollToSelection();
+                this->jumpIfOffScreen();
             }
         });
         ShortcutManager::addShortcut(this, Keys::Right, [this] {
             auto pos = this->m_selectionEnd + 1;
             this->setSelection(pos, pos);
             this->scrollToSelection();
+            this->jumpIfOffScreen();
         });
 
         ShortcutManager::addShortcut(this, Keys::PageUp, [this] {
@@ -1085,32 +1095,37 @@ namespace hex::plugin::builtin {
                 auto pos = this->m_selectionEnd - visibleByteCount;
                 this->setSelection(pos, pos);
                 this->scrollToSelection();
+                this->jumpIfOffScreen();
             }
         });
         ShortcutManager::addShortcut(this, Keys::PageDown, [this] {
             auto pos = this->m_selectionEnd + (this->m_bytesPerRow * this->m_visibleRowCount);
             this->setSelection(pos, pos);
             this->scrollToSelection();
+            this->jumpIfOffScreen();
         });
 
         // Move selection around
         ShortcutManager::addShortcut(this, SHIFT + Keys::Up, [this] {
             this->setSelection(this->m_selectionEnd - this->m_bytesPerRow, this->m_selectionEnd);
             this->scrollToSelection();
+            this->jumpIfOffScreen();
         });
         ShortcutManager::addShortcut(this, SHIFT + Keys::Down, [this] {
             this->setSelection(this->m_selectionEnd + this->m_bytesPerRow, this->m_selectionEnd);
             this->scrollToSelection();
+            this->jumpIfOffScreen();
 
         });
         ShortcutManager::addShortcut(this, SHIFT + Keys::Left, [this] {
             this->setSelection(this->m_selectionEnd - 1, this->m_selectionEnd);
             this->scrollToSelection();
-
+            this->jumpIfOffScreen();
         });
         ShortcutManager::addShortcut(this, SHIFT + Keys::Right, [this] {
             this->setSelection(this->m_selectionEnd + 1, this->m_selectionEnd);
             this->scrollToSelection();
+            this->jumpIfOffScreen();
         });
 
         ShortcutManager::addShortcut(this, CTRL + Keys::G, [this] {

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

@@ -254,7 +254,7 @@ namespace hex::plugin::builtin {
                 if (child != nullptr) {
                     ImGui::BeginTooltip();
 
-                    if (ImGui::BeginTable("##tooltips", 1, ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
+                    if (ImGui::BeginTable("##tooltips", 1, ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
                         ImGui::TableNextRow();
                         ImGui::TableNextColumn();
 

plugins/builtin/source/lang/de_DE.cpp

@@ -215,11 +215,14 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.view.disassembler.disassembly.bytes", "Byte" },
 
                 { "hex.builtin.view.hashes.name", "Hashes" },
-                    { "hex.builtin.view.hashes.settings", "Einstellungen" },
-                    { "hex.builtin.view.hashes.function", "Hash Funktion" },
-                    { "hex.builtin.view.hashes.iv", "Startwert" },
-                    { "hex.builtin.view.hashes.poly", "Polynomial" },
+                    { "hex.builtin.view.hashes.hash", "Hash" },
+                    { "hex.builtin.view.hashes.no_settings", "Keine Einstellungen verfügbar" },
+                    { "hex.builtin.view.hashes.function", "Hashfunktion" },
+                    { "hex.builtin.view.hashes.name", "Name" },
+                    { "hex.builtin.view.hashes.type", "Typ" },
                     { "hex.builtin.view.hashes.result", "Resultat" },
+                    { "hex.builtin.view.hashes.remove", "Hash entfernen" },
+                    { "hex.builtin.view.hashes.hover_info", "Bewege die Maus über die seketierten Bytes im Hex Editor und halte SHIFT gedrückt, um die Hashes dieser Region anzuzeigen." },
 
                 { "hex.builtin.view.help.name", "Hilfe" },
                     { "hex.builtin.view.help.about.name", "Über ImHex" },
@@ -641,6 +644,20 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.tools.file_tools.combiner.error.open_output", "Erstellen der Zieldatei fehlgeschlagen" },
                         { "hex.builtin.tools.file_tools.combiner.open_input", "Öffnen der Inputdatei {0} fehlgeschlagen" },
                         { "hex.builtin.tools.file_tools.combiner.success", "Dateien erfolgreich kombiniert!" },
+                { "hex.builtin.tools.ieee756", "IEEE 756 Fliesskommazahl Tester" },
+                    { "hex.builtin.tools.ieee756.sign", "Vorzeichen" },
+                    { "hex.builtin.tools.ieee756.exponent", "Exponent" },
+                    { "hex.builtin.tools.ieee756.mantissa", "Mantisse" },
+                    { "hex.builtin.tools.ieee756.exponent_size", "Exponentengrösse" },
+                    { "hex.builtin.tools.ieee756.mantissa_size", "Mantissengrösse" },
+                    { "hex.builtin.tools.ieee756.half_precision", "Half Precision" },
+                    { "hex.builtin.tools.ieee756.singe_precision", "Single Precision" },
+                    { "hex.builtin.tools.ieee756.double_precision", "Double Precision" },
+                    { "hex.builtin.tools.ieee756.type", "Typ" },
+                    { "hex.builtin.tools.ieee756.formula", "Formel" },
+                    { "hex.builtin.tools.ieee756.result.title", "Resultat" },
+                    { "hex.builtin.tools.ieee756.result.float", "Fliesskomma Resultat" },
+                    { "hex.builtin.tools.ieee756.result.hex", "Hexadezimal Resultat" },
 
                 { "hex.builtin.setting.imhex", "ImHex" },
                     { "hex.builtin.setting.imhex.recent_files", "Kürzlich geöffnete Dateien" },
@@ -715,6 +732,21 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.visualizer.floating_point.64bit", "Floating Point (64 bits)" },
                 { "hex.builtin.visualizer.hexii", "HexII" },
                 { "hex.builtin.visualizer.rgba8", "RGBA8 Farbe" },
+
+                { "hex.builtin.hash.md5", "MD5" },
+                { "hex.builtin.hash.sha1", "SHA1" },
+                { "hex.builtin.hash.sha224", "SHA224" },
+                { "hex.builtin.hash.sha256", "SHA256" },
+                { "hex.builtin.hash.sha384", "SHA384" },
+                { "hex.builtin.hash.sha512", "SHA512" },
+                { "hex.builtin.hash.crc8", "CRC8" },
+                { "hex.builtin.hash.crc16", "CRC16" },
+                { "hex.builtin.hash.crc32", "CRC32" },
+                    { "hex.builtin.hash.crc.poly", "Polynom" },
+                    { "hex.builtin.hash.crc.iv", "Initialwert" },
+                    { "hex.builtin.hash.crc.xor_out", "XOR Out" },
+                    { "hex.builtin.hash.crc.refl_in", "Reflect In" },
+                    { "hex.builtin.hash.crc.refl_out", "Reflect Out" },
         });
     }
 

plugins/builtin/source/lang/en_US.cpp

@@ -218,14 +218,14 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.view.disassembler.disassembly.bytes", "Byte" },
 
                 { "hex.builtin.view.hashes.name", "Hashes" },
-                    { "hex.builtin.view.hashes.settings", "Settings" },
+                    { "hex.builtin.view.hashes.hash", "Hash" },
+                    { "hex.builtin.view.hashes.no_settings", "No settings available" },
                     { "hex.builtin.view.hashes.function", "Hash function" },
-                    { "hex.builtin.view.hashes.iv", "Initial value" },
-                    { "hex.builtin.view.hashes.xorout", "Final XOR value" },
-                    { "hex.builtin.common.reflectIn", "Reflect input" },
-                    { "hex.builtin.common.reflectOut", "Reflect output" },
-                    { "hex.builtin.view.hashes.poly", "Polynomial" },
+                    { "hex.builtin.view.hashes.name", "Name" },
+                    { "hex.builtin.view.hashes.type", "Type" },
                     { "hex.builtin.view.hashes.result", "Result" },
+                    { "hex.builtin.view.hashes.remove", "Remove hash" },
+                    { "hex.builtin.view.hashes.hover_info", "Hover over the Hex Editor selection and hold down SHIFT to view the hashes of that region." },
 
                 { "hex.builtin.view.help.name", "Help" },
                     { "hex.builtin.view.help.about.name", "About" },
@@ -645,6 +645,20 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.tools.file_tools.combiner.error.open_output", "Failed to create output file" },
                         { "hex.builtin.tools.file_tools.combiner.open_input", "Failed to open input file {0}" },
                         { "hex.builtin.tools.file_tools.combiner.success", "Files combined successfully!" },
+                { "hex.builtin.tools.ieee756", "IEEE 756 Floating Point Tester" },
+                    { "hex.builtin.tools.ieee756.sign", "Sign" },
+                    { "hex.builtin.tools.ieee756.exponent", "Exponent" },
+                    { "hex.builtin.tools.ieee756.mantissa", "Mantissa" },
+                    { "hex.builtin.tools.ieee756.exponent_size", "Exponent Size" },
+                    { "hex.builtin.tools.ieee756.mantissa_size", "Mantissa Size" },
+                    { "hex.builtin.tools.ieee756.half_precision", "Half Precision" },
+                    { "hex.builtin.tools.ieee756.singe_precision", "Single Precision" },
+                    { "hex.builtin.tools.ieee756.double_precision", "Double Precision" },
+                    { "hex.builtin.tools.ieee756.type", "Type" },
+                    { "hex.builtin.tools.ieee756.formula", "Formula" },
+                    { "hex.builtin.tools.ieee756.result.title", "Result" },
+                    { "hex.builtin.tools.ieee756.result.float", "Floating Point Result" },
+                    { "hex.builtin.tools.ieee756.result.hex", "Hexadecimal Result" },
 
                 { "hex.builtin.setting.imhex", "ImHex" },
                     { "hex.builtin.setting.imhex.recent_files", "Recent Files" },
@@ -719,6 +733,21 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.visualizer.floating_point.64bit", "Floating Point (64 bits)" },
                 { "hex.builtin.visualizer.hexii", "HexII" },
                 { "hex.builtin.visualizer.rgba8", "RGBA8 Color" },
+
+                { "hex.builtin.hash.md5", "MD5" },
+                { "hex.builtin.hash.sha1", "SHA1" },
+                { "hex.builtin.hash.sha224", "SHA224" },
+                { "hex.builtin.hash.sha256", "SHA256" },
+                { "hex.builtin.hash.sha384", "SHA384" },
+                { "hex.builtin.hash.sha512", "SHA512" },
+                { "hex.builtin.hash.crc8", "CRC8" },
+                { "hex.builtin.hash.crc16", "CRC16" },
+                { "hex.builtin.hash.crc32", "CRC32" },
+                    { "hex.builtin.hash.crc.poly", "Polynomial" },
+                    { "hex.builtin.hash.crc.iv", "Initial Value" },
+                    { "hex.builtin.hash.crc.xor_out", "XOR Out" },
+                    { "hex.builtin.hash.crc.refl_in", "Reflect In" },
+                    { "hex.builtin.hash.crc.refl_out", "Reflect Out" },
         });
     }
 

plugins/builtin/source/lang/it_IT.cpp

@@ -216,11 +216,15 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.view.disassembler.disassembly.bytes", "Byte" },
 
                 { "hex.builtin.view.hashes.name", "Hash" },
-                    { "hex.builtin.view.hashes.settings", "Impostazioni" },
+                    { "hex.builtin.view.hashes.hash", "Hash" },
+                    //{ "hex.builtin.view.hashes.no_settings", "No settings available" },
                     { "hex.builtin.view.hashes.function", "Funzioni di Hash" },
-                    { "hex.builtin.view.hashes.iv", "Valore Iniziale" },
-                    { "hex.builtin.view.hashes.poly", "Polinomio" },
+                    //{ "hex.builtin.view.hashes.name", "Name" },
+                    //{ "hex.builtin.view.hashes.type", "Type" },
                     { "hex.builtin.view.hashes.result", "Risultato" },
+                    //{ "hex.builtin.view.hashes.remove", "Remove hash" },
+                    //{ "hex.builtin.view.hashes.hover_info", "Hover over the Hex Editor selection and hold down SHIFT to view the hashes of that region." },
+
 
                 { "hex.builtin.view.help.name", "Aiuto" },
                     { "hex.builtin.view.help.about.name", "Riguardo ImHex" },
@@ -646,6 +650,20 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.tools.file_tools.combiner.error.open_output", "Impossibile creare file di output" },
                         { "hex.builtin.tools.file_tools.combiner.open_input", "Impossibile aprire file di input {0}" },
                         { "hex.builtin.tools.file_tools.combiner.success", "File combinato con successo!" },
+                //{ "hex.builtin.tools.ieee756", "IEEE 756 Floating Point Tester" },
+                    //{ "hex.builtin.tools.ieee756.sign", "Sign" },
+                    //{ "hex.builtin.tools.ieee756.exponent", "Exponent" },
+                    //{ "hex.builtin.tools.ieee756.mantissa", "Mantissa" },
+                    //{ "hex.builtin.tools.ieee756.exponent_size", "Exponent Size" },
+                    //{ "hex.builtin.tools.ieee756.mantissa_size", "Mantissa Size" },
+                    //{ "hex.builtin.tools.ieee756.half_precision", "Half Precision" },
+                    //{ "hex.builtin.tools.ieee756.singe_precision", "Single Precision" },
+                    //{ "hex.builtin.tools.ieee756.double_precision", "Double Precision" },
+                    //{ "hex.builtin.tools.ieee756.type", "Type" },
+                    //{ "hex.builtin.tools.ieee756.formula", "Formula" },
+                    //{ "hex.builtin.tools.ieee756.result.title", "Result" },
+                    //{ "hex.builtin.tools.ieee756.result.float", "Floating Point Result" },
+                    //{ "hex.builtin.tools.ieee756.result.hex", "Hexadecimal Result" },
 
                 { "hex.builtin.setting.imhex", "ImHex" },
                     { "hex.builtin.setting.imhex.recent_files", "File recenti" },
@@ -720,6 +738,21 @@ namespace hex::plugin::builtin {
                 //{ "hex.builtin.visualizer.floating_point.64bit", "Floating Point (64 bits)" },
                 //{ "hex.builtin.visualizer.hexii", "HexII" },
                 //{ "hex.builtin.visualizer.rgba8", "RGBA8 Color" },
+
+                { "hex.builtin.hash.md5", "MD5" },
+                { "hex.builtin.hash.sha1", "SHA1" },
+                { "hex.builtin.hash.sha224", "SHA224" },
+                { "hex.builtin.hash.sha256", "SHA256" },
+                { "hex.builtin.hash.sha384", "SHA384" },
+                { "hex.builtin.hash.sha512", "SHA512" },
+                { "hex.builtin.hash.crc8", "CRC8" },
+                { "hex.builtin.hash.crc16", "CRC16" },
+                { "hex.builtin.hash.crc32", "CRC32" },
+                    { "hex.builtin.hash.crc.poly", "Polinomio" },
+                    { "hex.builtin.hash.crc.iv", "Valore Iniziale" },
+                    //{ "hex.builtin.hash.crc.xor_out", "XOR Out" },
+                    //{ "hex.builtin.hash.crc.refl_in", "Reflect In" },
+                    //{ "hex.builtin.hash.crc.refl_out", "Reflect Out" },
         });
     }
 

plugins/builtin/source/lang/ja_JP.cpp

@@ -218,14 +218,14 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.view.disassembler.disassembly.bytes", "バイト" },
 
                 { "hex.builtin.view.hashes.name", "ハッシュ" },
-                    { "hex.builtin.view.hashes.settings", "設定" },
+                    //{ "hex.builtin.view.hashes.hash", "Hash" },
+                    //{ "hex.builtin.view.hashes.no_settings", "No settings available" },
                     { "hex.builtin.view.hashes.function", "ハッシュ関数" },
-                    { "hex.builtin.view.hashes.iv", "初期値" },
-                    { "hex.builtin.view.hashes.xorout", "最終XOR値" },
-                    { "hex.builtin.common.reflectIn", "入力を反映" },
-                    { "hex.builtin.common.reflectOut", "出力を反映" },
-                    { "hex.builtin.view.hashes.poly", "多項式" },
+                    //{ "hex.builtin.view.hashes.name", "Name" },
+                    //{ "hex.builtin.view.hashes.type", "Type" },
                     { "hex.builtin.view.hashes.result", "結果" },
+                    //{ "hex.builtin.view.hashes.remove", "Remove hash" },
+                    //{ "hex.builtin.view.hashes.hover_info", "Hover over the Hex Editor selection and hold down SHIFT to view the hashes of that region." },
 
                 { "hex.builtin.view.help.name", "ヘルプ" },
                     { "hex.builtin.view.help.about.name", "このソフトについて" },
@@ -646,6 +646,20 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.tools.file_tools.combiner.error.open_output", "出力ファイルを作成できませんでした" },
                         { "hex.builtin.tools.file_tools.combiner.open_input", "入力ファイル {0} を開けませんでした" },
                         { "hex.builtin.tools.file_tools.combiner.success", "ファイルの結合に成功しました！" },
+                //{ "hex.builtin.tools.ieee756", "IEEE 756 Floating Point Tester" },
+                    //{ "hex.builtin.tools.ieee756.sign", "Sign" },
+                    //{ "hex.builtin.tools.ieee756.exponent", "Exponent" },
+                    //{ "hex.builtin.tools.ieee756.mantissa", "Mantissa" },
+                    //{ "hex.builtin.tools.ieee756.exponent_size", "Exponent Size" },
+                    //{ "hex.builtin.tools.ieee756.mantissa_size", "Mantissa Size" },
+                    //{ "hex.builtin.tools.ieee756.half_precision", "Half Precision" },
+                    //{ "hex.builtin.tools.ieee756.singe_precision", "Single Precision" },
+                    //{ "hex.builtin.tools.ieee756.double_precision", "Double Precision" },
+                    //{ "hex.builtin.tools.ieee756.type", "Type" },
+                    //{ "hex.builtin.tools.ieee756.formula", "Formula" },
+                    //{ "hex.builtin.tools.ieee756.result.title", "Result" },
+                    //{ "hex.builtin.tools.ieee756.result.float", "Floating Point Result" },
+                    //{ "hex.builtin.tools.ieee756.result.hex", "Hexadecimal Result" },
 
                 { "hex.builtin.setting.imhex", "ImHex" },
                     { "hex.builtin.setting.imhex.recent_files", "最近開いたファイル" },
@@ -721,6 +735,21 @@ namespace hex::plugin::builtin {
                 //{ "hex.builtin.visualizer.floating_point.64bit", "Floating Point (64 bits)" },
                 //{ "hex.builtin.visualizer.hexii", "HexII" },
                 //{ "hex.builtin.visualizer.rgba8", "RGBA8 Color" },
+
+                { "hex.builtin.hash.md5", "MD5" },
+                { "hex.builtin.hash.sha1", "SHA1" },
+                { "hex.builtin.hash.sha224", "SHA224" },
+                { "hex.builtin.hash.sha256", "SHA256" },
+                { "hex.builtin.hash.sha384", "SHA384" },
+                { "hex.builtin.hash.sha512", "SHA512" },
+                { "hex.builtin.hash.crc8", "CRC8" },
+                { "hex.builtin.hash.crc16", "CRC16" },
+                { "hex.builtin.hash.crc32", "CRC32" },
+                    { "hex.builtin.hash.crc.poly", "多項式" },
+                    { "hex.builtin.hash.crc.iv", "初期値" },
+                    { "hex.builtin.hash.crc.xor_out", "最終XOR値" },
+                    { "hex.builtin.hash.crc.refl_in", "入力を反映" },
+                    { "hex.builtin.hash.crc.refl_out", "出力を反映" },
         });
     }
 

plugins/builtin/source/lang/pt_BR.cpp

@@ -0,0 +1,754 @@
+#include <hex/api/content_registry.hpp>
+#include <hex/api/localization.hpp>
+
+namespace hex::plugin::builtin {
+
+    void registerLanguagePtBR() {
+        ContentRegistry::Language::registerLanguage("Portuguese (Brazilian)", "pt-BR");
+        LangEntry::setFallbackLanguage("pt-BR");
+
+        ContentRegistry::Language::addLocalizations("pt-BR", {
+                { "hex.builtin.welcome.header.main", "Bem-vindo ao ImHex" },
+                { "hex.builtin.welcome.header.start", "Iniciar" },
+                    { "hex.builtin.welcome.start.create_file", "Criar Novo Arquivo" },
+                    { "hex.builtin.welcome.start.open_file", "Abrir Arquivo" },
+                    { "hex.builtin.welcome.start.open_project", "Abrir Projeto" },
+                    { "hex.builtin.welcome.start.recent", "Arquivos Recentes" },
+                    { "hex.builtin.welcome.start.open_other", "Outros Provedores" },
+                { "hex.builtin.welcome.header.help", "Ajuda" },
+                    { "hex.builtin.welcome.help.repo", "Repositório do GitHub" },
+                        { "hex.builtin.welcome.help.repo.link", "https://imhex.werwolv.net/git" },
+                    { "hex.builtin.welcome.help.gethelp", "Obter Ajuda" },
+                        { "hex.builtin.welcome.help.gethelp.link", "https://github.com/WerWolv/ImHex/discussions/categories/get-help" },
+                    { "hex.builtin.welcome.help.discord", "Servidor do Discord" },
+                        { "hex.builtin.welcome.help.discord.link", "https://imhex.werwolv.net/discord" },
+                { "hex.builtin.welcome.header.plugins", "Plugins Carregados" },
+                    { "hex.builtin.welcome.plugins.plugin", "Plugin" },
+                    { "hex.builtin.welcome.plugins.author", "Autor" },
+                    { "hex.builtin.welcome.plugins.desc", "Descrição" },
+                { "hex.builtin.welcome.header.customize", "Customizar" },
+                    { "hex.builtin.welcome.customize.settings.title", "Configurações" },
+                    { "hex.builtin.welcome.customize.settings.desc", "Mudar preferencias do ImHex" },
+                { "hex.builtin.welcome.header.update", "Atualizações" },
+                    { "hex.builtin.welcome.update.title", "Nova atualização disponivel!" },
+                    { "hex.builtin.welcome.update.desc", "ImHex {0} acabou de lançar! Baixe aqui." },
+                    { "hex.builtin.welcome.update.link", "https://github.com/WerWolv/ImHex/releases/latest" },
+                { "hex.builtin.welcome.header.learn", "Aprender" },
+                    { "hex.builtin.welcome.learn.latest.title", "Último lançamento" },
+                    { "hex.builtin.welcome.learn.latest.desc", "Leia o changelog atual do ImHex" },
+                    { "hex.builtin.welcome.learn.latest.link", "https://github.com/WerWolv/ImHex/releases/latest" },
+                    { "hex.builtin.welcome.learn.pattern.title", "Documentação da linguagem padrão" },
+                    { "hex.builtin.welcome.learn.pattern.desc", "Aprenda a escrever padrões ImHex com nossa extensa documentação" },
+                    { "hex.builtin.welcome.learn.pattern.link", "https://imhex.werwolv.net/docs/pattern_language/pattern_language.html" },
+                    { "hex.builtin.welcome.learn.plugins.title", "Plugins API" },
+                    { "hex.builtin.welcome.learn.plugins.desc", "Estenda o ImHex com recursos adicionais usando plugins" },
+                    { "hex.builtin.welcome.learn.plugins.link", "https://github.com/WerWolv/ImHex/wiki/Plugins-Development-Guide" },
+                { "hex.builtin.welcome.header.various", "Vários" },
+                { "hex.builtin.welcome.tip_of_the_day", "Dica do Dia" },
+
+                { "hex.builtin.welcome.safety_backup.title", "Restaurar dados perdidos" },
+                { "hex.builtin.welcome.safety_backup.desc", "Ah não, ImHex crashou na ultima vez.\nDeseja restaurar seu trabalho anterior?"},
+                { "hex.builtin.welcome.safety_backup.restore", "Yes, Restaurar" },
+                { "hex.builtin.welcome.safety_backup.delete", "Não, Apagar" },
+
+                { "hex.builtin.common.endian", "Endian" },
+                { "hex.builtin.common.little_endian", "Little Endian" },
+                { "hex.builtin.common.big_endian", "Big Endian" },
+                { "hex.builtin.common.little", "Little" },
+                { "hex.builtin.common.big", "Big" },
+                { "hex.builtin.common.number_format", "Format" },
+                { "hex.builtin.common.decimal", "Decimal" },
+                { "hex.builtin.common.hexadecimal", "Hexadecimal" },
+                { "hex.builtin.common.octal", "Octal" },
+                { "hex.builtin.common.info", "Informação" },
+                { "hex.builtin.common.error", "Erro" },
+                { "hex.builtin.common.fatal", "Erro Fatal" },
+                { "hex.builtin.common.question", "Question" },
+                { "hex.builtin.common.address", "Address" },
+                { "hex.builtin.common.size", "Tamanho" },
+                { "hex.builtin.common.region", "Region" },
+                { "hex.builtin.common.match_selection", "Seleção de correspondência" },
+                { "hex.builtin.common.yes", "Sim" },
+                { "hex.builtin.common.no", "Não" },
+                { "hex.builtin.common.okay", "OK" },
+                { "hex.builtin.common.load", "Carregar" },
+                { "hex.builtin.common.cancel", "Cancelar" },
+                { "hex.builtin.common.set", "Colocar" },
+                { "hex.builtin.common.close", "Fechar" },
+                { "hex.builtin.common.dont_show_again", "Não Mostrar Novamente" },
+                { "hex.builtin.common.link", "Link" },
+                { "hex.builtin.common.file", "Arquivo" },
+                { "hex.builtin.common.open", "Abrir" },
+                { "hex.builtin.common.browse", "Navegar..." },
+                { "hex.builtin.common.choose_file", "Escolher arquivo" },
+                { "hex.common.processing", "Processando" },
+
+                { "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?" },
+                { "hex.builtin.popup.error.read_only", "Não foi possível obter acesso de gravação. Arquivo aberto no modo somente leitura." },
+                { "hex.builtin.popup.error.open", "Falha ao abrir o arquivo!" },
+                { "hex.builtin.popup.error.create", "Falha ao criar um novo arquivo!" },
+
+                { "hex.builtin.menu.file", "File" },
+                    { "hex.builtin.menu.file.open_file", "Abrir Arquivo..." },
+                    { "hex.builtin.menu.file.open_recent", "Abrir Recentes" },
+                    { "hex.builtin.menu.file.clear_recent", "Limpar" },
+                    { "hex.builtin.menu.file.open_other", "Abrir outro..." },
+                    { "hex.builtin.menu.file.close", "Fechar" },
+                    { "hex.builtin.menu.file.quit", "Sair do ImHex" },
+                    { "hex.builtin.menu.file.open_project", "Abrir Projeto..." },
+                    { "hex.builtin.menu.file.save_project", "Salvar Projeto..." },
+                    { "hex.builtin.menu.file.import", "Importar..." },
+                        { "hex.builtin.menu.file.import.base64", "Arquivo Base64" },
+                          { "hex.builtin.menu.file.import.base64.popup.import_error", "Esse arquivo não é baseado em um formato Base64 valido!" },
+                          { "hex.builtin.menu.file.import.base64.popup.open_error", "Falha ao abrir o arquivo!" },
+                        { "hex.builtin.menu.file.import.ips", "IPS Patch" },
+                        { "hex.builtin.menu.file.import.ips32", "IPS32 Patch" },
+                    { "hex.builtin.menu.file.export", "Exportar..." },
+                        { "hex.builtin.menu.file.export.title", "Exportar Arquivo" },
+                        { "hex.builtin.menu.file.export.ips", "IPS Patch" },
+                        { "hex.builtin.menu.file.export.ips32", "IPS32 Patch" },
+                        { "hex.builtin.menu.file.export.base64.popup.export_error", "Esse arquivo não é baseado em um formato Base64 valido!" },
+                    { "hex.builtin.menu.file.export.popup.create", "Não é possível exportar os dados. Falha ao criar arquivo!" },
+
+                { "hex.builtin.menu.edit", "Editar" },
+                    { "hex.builtin.menu.edit.undo", "Desfazer" },
+                    { "hex.builtin.menu.edit.redo", "Refazer" },
+                    { "hex.builtin.menu.edit.bookmark", "Criar Marcador" },
+
+                { "hex.builtin.menu.view", "Exibir" },
+                { "hex.builtin.menu.layout", "Layout" },
+                    { "hex.builtin.menu.view.fps", "Mostrar FPS" },
+                    { "hex.builtin.menu.view.demo", "Mostrar Demo do ImGui" },
+                { "hex.builtin.menu.help", "Ajuda" },
+
+                { "hex.builtin.view.bookmarks.name", "Favoritos" },
+                    { "hex.builtin.view.bookmarks.default_title", "Favorito [0x{0:X} - 0x{1:X}]" },
+                    { "hex.builtin.view.bookmarks.no_bookmarks", "Nenhum favorito criado. Adicione-o e Edite -> Criar Favorito" },
+                    { "hex.builtin.view.bookmarks.title.info", "Informação" },
+                    { "hex.builtin.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} bytes)" },
+                    { "hex.builtin.view.bookmarks.button.jump", "Pular para" },
+                    { "hex.builtin.view.bookmarks.button.remove", "Remover" },
+                    { "hex.builtin.view.bookmarks.header.name", "Nome" },
+                    { "hex.builtin.view.bookmarks.header.color", "Cor" },
+                    { "hex.builtin.view.bookmarks.header.comment", "Comentar" },
+
+                { "hex.builtin.view.command_palette.name", "Paleta de Comandos" },
+
+                { "hex.builtin.view.data_inspector.name", "Inspecionador de Dados" },
+                    { "hex.builtin.view.data_inspector.table.name", "Nome" },
+                    { "hex.builtin.view.data_inspector.table.value", "Valor" },
+                    { "hex.builtin.view.data_inspector.no_data", "Nenhum Byte Selecionado" },
+                    { "hex.builtin.view.data_inspector.invert", "Inverter" },
+
+                { "hex.builtin.view.data_processor.name", "Data Processor" },
+                    { "hex.builtin.view.data_processor.help_text", "Botão direito para adicionar um novo Node" },
+                    { "hex.builtin.view.data_processor.menu.remove_selection", "Remover Selecionado" },
+                    { "hex.builtin.view.data_processor.menu.remove_node", "Remover Node" },
+                    { "hex.builtin.view.data_processor.menu.remove_link", "Remover Link" },
+                    { "hex.builtin.view.data_processor.menu.file.load_processor", "Load data processor..." },
+                    { "hex.builtin.view.data_processor.menu.file.save_processor", "Save data processor..." },
+
+                { "hex.builtin.view.disassembler.name", "Desmontador" },
+                    { "hex.builtin.view.disassembler.position", "Posição" },
+                    { "hex.builtin.view.disassembler.base", "Endereço base" },
+                    { "hex.builtin.view.disassembler.region", "Região do código" },
+                    { "hex.builtin.view.disassembler.settings.header", "Configurações" },
+                    { "hex.builtin.view.disassembler.settings.mode", "Modo" },
+                    { "hex.builtin.view.disassembler.arch", "Arquitetura" },
+                        { "hex.builtin.view.disassembler.16bit", "16-bit" },
+                        { "hex.builtin.view.disassembler.32bit", "32-bit" },
+                        { "hex.builtin.view.disassembler.64bit", "64-bit" },
+
+                        { "hex.builtin.view.disassembler.arm.arm", "ARM" },
+                        { "hex.builtin.view.disassembler.arm.thumb", "Thumb" },
+                        { "hex.builtin.view.disassembler.arm.default", "Default" },
+                        { "hex.builtin.view.disassembler.arm.cortex_m", "Cortex-M" },
+                        { "hex.builtin.view.disassembler.arm.armv8", "ARMv8" },
+
+                        { "hex.builtin.view.disassembler.mips.mips32", "MIPS32" },
+                        { "hex.builtin.view.disassembler.mips.mips64", "MIPS64" },
+                        { "hex.builtin.view.disassembler.mips.mips32R6", "MIPS32R6" },
+                        { "hex.builtin.view.disassembler.mips.mips2", "MIPS II" },
+                        { "hex.builtin.view.disassembler.mips.mips3", "MIPS III" },
+                        { "hex.builtin.view.disassembler.mips.micro", "Micro" },
+
+                        { "hex.builtin.view.disassembler.ppc.qpx", "Quad Processing Extensions" },
+                        { "hex.builtin.view.disassembler.ppc.spe", "Signal Processing Engine" },
+                        { "hex.builtin.view.disassembler.ppc.booke", "Book-E" },
+
+                        { "hex.builtin.view.disassembler.sparc.v9", "Sparc V9" },
+
+                        { "hex.builtin.view.disassembler.riscv.compressed", "Compressed" },
+
+                        { "hex.builtin.view.disassembler.m68k.000", "000" },
+                        { "hex.builtin.view.disassembler.m68k.010", "010" },
+                        { "hex.builtin.view.disassembler.m68k.020", "020" },
+                        { "hex.builtin.view.disassembler.m68k.030", "030" },
+                        { "hex.builtin.view.disassembler.m68k.040", "040" },
+                        { "hex.builtin.view.disassembler.m68k.060", "060" },
+
+                        { "hex.builtin.view.disassembler.m680x.6301", "6301" },
+                        { "hex.builtin.view.disassembler.m680x.6309", "6309" },
+                        { "hex.builtin.view.disassembler.m680x.6800", "6800" },
+                        { "hex.builtin.view.disassembler.m680x.6801", "6801" },
+                        { "hex.builtin.view.disassembler.m680x.6805", "6805" },
+                        { "hex.builtin.view.disassembler.m680x.6808", "6808" },
+                        { "hex.builtin.view.disassembler.m680x.6809", "6809" },
+                        { "hex.builtin.view.disassembler.m680x.6811", "6811" },
+                        { "hex.builtin.view.disassembler.m680x.cpu12", "CPU12" },
+                        { "hex.builtin.view.disassembler.m680x.hcs08", "HCS08" },
+
+                        { "hex.builtin.view.disassembler.mos65xx.6502", "6502" },
+                        { "hex.builtin.view.disassembler.mos65xx.65c02", "65C02" },
+                        { "hex.builtin.view.disassembler.mos65xx.w65c02", "W65C02" },
+                        { "hex.builtin.view.disassembler.mos65xx.65816", "65816" },
+                        { "hex.builtin.view.disassembler.mos65xx.65816_long_m", "65816 Long M" },
+                        { "hex.builtin.view.disassembler.mos65xx.65816_long_x", "65816 Long X" },
+                        { "hex.builtin.view.disassembler.mos65xx.65816_long_mx", "65816 Long MX" },
+
+                        { "hex.builtin.view.disassembler.bpf.classic", "Classico" },
+                        { "hex.builtin.view.disassembler.bpf.extended", "Extendido" },
+
+                    { "hex.builtin.view.disassembler.disassemble", "Desmontar" },
+                    { "hex.builtin.view.disassembler.disassembling", "Desmontando..." },
+                    { "hex.builtin.view.disassembler.disassembly.title", "Disassembly" },
+                        { "hex.builtin.view.disassembler.disassembly.address", "Address" },
+                        { "hex.builtin.view.disassembler.disassembly.offset", "Offset" },
+                        { "hex.builtin.view.disassembler.disassembly.bytes", "Byte" },
+
+                { "hex.builtin.view.hashes.name", "Hashes" },
+                    { "hex.builtin.view.hashes.hash", "Hash" },
+                    { "hex.builtin.view.hashes.no_settings", "Nenhuma configuração disponivel" },
+                    { "hex.builtin.view.hashes.function", "Função Hash" },
+                    { "hex.builtin.view.hashes.name", "Nome" },
+                    { "hex.builtin.view.hashes.type", "Tipo" },
+                    { "hex.builtin.view.hashes.result", "Resultado" },
+                    { "hex.builtin.view.hashes.remove", "Remover hash" },
+                    { "hex.builtin.view.hashes.hover_info", "Passe o mouse sobre a seleção Hex Editor e mantenha pressionada a tecla SHIFT para visualizar os hashes dessa região." },
+
+                { "hex.builtin.view.help.name", "Ajuda" },
+                    { "hex.builtin.view.help.about.name", "Sobre" },
+                        { "hex.builtin.view.help.about.translator", "Traduzido por Douglas Vianna" },
+                        { "hex.builtin.view.help.about.source", "Código Fonte disponível no GitHub:" },
+                        { "hex.builtin.view.help.about.donations", "Doações" },
+                        { "hex.builtin.view.help.about.thanks", "Se você gosta do meu trabalho, considere doar para manter o projeto em andamento. Muito obrigado <3" },
+                        { "hex.builtin.view.help.about.contributor", "Contribuidores" },
+                        { "hex.builtin.view.help.about.libs", "Bibliotecas usadas" },
+                        { "hex.builtin.view.help.about.paths", "Diretórios do ImHex" },
+                        { "hex.builtin.view.help.about.license", "Licença" },
+                    { "hex.builtin.view.help.documentation", "Documentação do ImHex" },
+                    { "hex.builtin.view.help.pattern_cheat_sheet", "Pattern Language Cheat Sheet"},
+                    { "hex.builtin.view.help.calc_cheat_sheet", "Calculator Cheat Sheet" },
+
+                { "hex.builtin.view.hex_editor.name", "Editor Hex" },
+                    { "hex.builtin.view.hex_editor.page", "Pagina" },
+                    { "hex.builtin.view.hex_editor.selection", "Seleção" },
+                        { "hex.builtin.view.hex_editor.selection.none", "Nenhum" },
+                    { "hex.builtin.view.hex_editor.region", "Região" },
+                    { "hex.builtin.view.hex_editor.data_size", "Tamanho dos Dados" },
+                    { "hex.builtin.view.hex_editor.no_bytes", "Nenhum Byte Disponivel" },
+
+                    { "hex.builtin.view.hex_editor.menu.file.load_encoding_file", "Carregar codificação personalizada..." },
+                    { "hex.builtin.view.hex_editor.menu.file.search", "Procurar" },
+                        { "hex.builtin.view.hex_editor.search.string", "String" },
+                        { "hex.builtin.view.hex_editor.search.hex", "Hex" },
+                        { "hex.builtin.view.hex_editor.search.find", "Buscar" },
+                    { "hex.builtin.view.hex_editor.menu.file.goto", "Ir para" },
+                        { "hex.builtin.view.hex_editor.goto.offset.absolute", "Absoluto" },
+                        { "hex.builtin.view.hex_editor.goto.offset.relative", "Relativo" },
+                        { "hex.builtin.view.hex_editor.goto.offset.begin", "Começo" },
+                        { "hex.builtin.view.hex_editor.goto.offset.end", "Fim" },
+                    { "hex.builtin.view.hex_editor.menu.file.save", "Salvar" },
+                    { "hex.builtin.view.hex_editor.menu.file.save_as", "Salvar como..." },
+                    { "hex.builtin.view.hex_editor.menu.edit.copy", "Copiar" },
+                    { "hex.builtin.view.hex_editor.menu.edit.copy_as", "Copiar como..." },
+                        { "hex.builtin.view.hex_editor.copy.hex", "String" },
+                        { "hex.builtin.view.hex_editor.copy.c", "C Array" },
+                        { "hex.builtin.view.hex_editor.copy.cpp", "C++ Array" },
+                        { "hex.builtin.view.hex_editor.copy.csharp", "C# Array" },
+                        { "hex.builtin.view.hex_editor.copy.rust", "Rust Array" },
+                        { "hex.builtin.view.hex_editor.copy.python", "Python Array" },
+                        { "hex.builtin.view.hex_editor.copy.java", "Java Array" },
+                        { "hex.builtin.view.hex_editor.copy.js", "JavaScript Array" },
+                        { "hex.builtin.view.hex_editor.copy.ascii", "ASCII Art" },
+                        { "hex.builtin.view.hex_editor.copy.html", "HTML" },
+                    { "hex.builtin.view.hex_editor.menu.edit.paste", "Colar" },
+                    { "hex.builtin.view.hex_editor.menu.edit.select_all", "Selecionar tudo" },
+                    { "hex.builtin.view.hex_editor.menu.edit.set_base", "Definir endereço base" },
+                    { "hex.builtin.view.hex_editor.menu.edit.resize", "Redimensionar..." },
+                    { "hex.builtin.view.hex_editor.menu.edit.insert", "Inserir..." },
+
+                { "hex.builtin.view.information.name", "Data Information" },
+                    { "hex.builtin.view.information.control", "Controle" },
+                    { "hex.builtin.view.information.analyze", "Analisar Pagina" },
+                    { "hex.builtin.view.information.analyzing", "Analizando..." },
+                    { "hex.builtin.view.information.region", "Região analizada" },
+                    { "hex.builtin.view.information.magic", "Informação Mágica" },
+                    { "hex.builtin.view.information.description", "Descrição:" },
+                    { "hex.builtin.view.information.mime", "MIME Type:" },
+                    { "hex.builtin.view.information.info_analysis", "Análise de Informações" },
+                    { "hex.builtin.view.information.distribution", "Byte distribution" },
+                    { "hex.builtin.view.information.entropy", "Entropy" },
+                    { "hex.builtin.view.information.block_size", "Block size" },
+                    { "hex.builtin.view.information.block_size.desc", "{0} blocks of {1} bytes" },
+                    { "hex.builtin.view.information.file_entropy", "File entropy" },
+                    { "hex.builtin.view.information.highest_entropy", "Highest entropy block" },
+                    { "hex.builtin.view.information.encrypted", "Esses dados provavelmente estão criptografados ou compactados!" },
+                    { "hex.builtin.view.information.magic_db_added", "Magic database added!" },
+
+                { "hex.builtin.view.patches.name", "Patches" },
+                    { "hex.builtin.view.patches.offset", "Desvio" },
+                    { "hex.builtin.view.patches.orig", "Valor Original" },
+                    { "hex.builtin.view.patches.patch", "Valor Atualizado"},
+                    { "hex.builtin.view.patches.remove", "Remover Atualização" },
+
+                { "hex.builtin.view.pattern_editor.name", "Editor de padrões" },
+                { "hex.builtin.view.pattern_editor.accept_pattern", "Aceitar padrão" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.desc", "Um ou mais padrão_linguagem compatível com este tipo de dados foi encontrado" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.pattern_language", "Padrões" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.question", "Deseja aplicar o padrão selecionado?" },
+                { "hex.builtin.view.pattern_editor.menu.file.load_pattern", "Carregando padrão..." },
+                { "hex.builtin.view.pattern_editor.menu.file.save_pattern", "Salvando padrão..." },
+                { "hex.builtin.view.pattern_editor.open_pattern", "Abrir padrão" },
+                { "hex.builtin.view.pattern_editor.evaluating", "Avaliando..." },
+                { "hex.builtin.view.pattern_editor.auto", "Auto Avaliar" },
+                { "hex.builtin.view.pattern_editor.console", "Console" },
+                { "hex.builtin.view.pattern_editor.env_vars", "Variáveis de Ambiente" },
+                { "hex.builtin.view.pattern_editor.settings", "Configurações" },
+                { "hex.builtin.view.pattern_editor.dangerous_function.name", "Permitir função perigosa?" },
+                { "hex.builtin.view.pattern_editor.dangerous_function.desc", "Este padrão tentou chamar uma função perigosa.\nTem certeza de que deseja confiar neste padrão?" },
+                { "hex.builtin.view.pattern_editor.no_in_out_vars", "Defina algumas variáveis globais com o especificador 'in' ou 'out' para que elas apareçam aqui." },
+
+                { "hex.builtin.view.pattern_data.name", "Padrão de Dados" },
+                    { "hex.builtin.view.pattern_data.var_name", "Nome" },
+                    { "hex.builtin.view.pattern_data.color", "Cor" },
+                    { "hex.builtin.view.pattern_data.offset", "Offset" },
+                    { "hex.builtin.view.pattern_data.size", "Tamanho" },
+                    { "hex.builtin.view.pattern_data.type", "Tipo" },
+                    { "hex.builtin.view.pattern_data.value", "Valor" },
+
+                { "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.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" },
+                    { "hex.builtin.view.yara.header.rules", "Regras" },
+                        { "hex.builtin.view.yara.reload", "Recarregar" },
+                        { "hex.builtin.view.yara.match", "Combinar Regras" },
+                        { "hex.builtin.view.yara.matching", "Combinando..." },
+                        { "hex.builtin.view.yara.error", "Erro do compilador Yara: " },
+                    { "hex.builtin.view.yara.header.matches", "Combinações" },
+                        { "hex.builtin.view.yara.matches.identifier", "Identificador" },
+                        { "hex.builtin.view.yara.matches.variable", "Variável" },
+                        { "hex.builtin.view.yara.whole_data", "O arquivo inteiro corresponde!" },
+                        { "hex.builtin.view.yara.no_rules", "Nenhuma regra YARA encontrada. Coloque-os na pasta 'yara' do ImHex" },
+                    { "hex.builtin.view.yara.rule_added", "Regra Yara Adicionada!" },
+
+
+                { "hex.builtin.view.constants.name", "Constantes" },
+                    { "hex.builtin.view.constants.row.category", "Categoria" },
+                    { "hex.builtin.view.constants.row.name", "Nome" },
+                    { "hex.builtin.view.constants.row.desc", "Descrição" },
+                    { "hex.builtin.view.constants.row.value", "Valor" },
+
+                { "hex.builtin.view.store.name", "Loja de Conteúdo" },
+                    { "hex.builtin.view.store.desc", "Baixe novos conteúdos do banco de dados online da ImHex" },
+                    { "hex.builtin.view.store.reload", "Recarregar" },
+                    { "hex.builtin.view.store.row.name", "Nome" },
+                    { "hex.builtin.view.store.row.description", "Descrição" },
+                    { "hex.builtin.view.store.download", "Baixar" },
+                    { "hex.builtin.view.store.update", "Atualizar" },
+                    { "hex.builtin.view.store.remove", "Remover" },
+                    { "hex.builtin.view.store.tab.patterns", "Padrões" },
+                    { "hex.builtin.view.store.tab.libraries", "Bibliotecas" },
+                    { "hex.builtin.view.store.tab.magics", "Arquivos Mágicos" },
+                    { "hex.builtin.view.store.tab.constants", "Constantes" },
+                    { "hex.builtin.view.store.tab.yara", "Regras Yara" },
+                    { "hex.builtin.view.store.tab.encodings", "Codificações" },
+                    { "hex.builtin.view.store.loading", "Carregando conteúdo da loja..." },
+                    { "hex.builtin.view.store.download_error", "Falha ao baixar o arquivo! A pasta de destino não existe." },
+
+                { "hex.builtin.view.diff.name", "Diferenciando" },
+
+                { "hex.builtin.view.provider_settings.name", "Configurações do provedor" },
+                    { "hex.builtin.view.provider_settings.load_popup", "Abrir Provedor" },
+
+                { "hex.builtin.command.calc.desc", "Calculadora" },
+                { "hex.builtin.command.cmd.desc", "Comando" },
+                { "hex.builtin.command.cmd.result", "Iniciar Comando '{0}'" },
+                { "hex.builtin.command.web.desc", "Website lookup" },
+                { "hex.builtin.command.web.result", "Navegar para '{0}'" },
+
+                { "hex.builtin.inspector.binary", "Binary (8 bit)" },
+                { "hex.builtin.inspector.u8", "uint8_t" },
+                { "hex.builtin.inspector.i8", "int8_t" },
+                { "hex.builtin.inspector.u16", "uint16_t" },
+                { "hex.builtin.inspector.i16", "int16_t" },
+                { "hex.builtin.inspector.u32", "uint32_t" },
+                { "hex.builtin.inspector.i32", "int32_t" },
+                { "hex.builtin.inspector.u64", "uint64_t" },
+                { "hex.builtin.inspector.i64", "int64_t" },
+                { "hex.builtin.inspector.float16", "half float (16 bit)" },
+                { "hex.builtin.inspector.float", "float (32 bit)" },
+                { "hex.builtin.inspector.double", "double (64 bit)" },
+                { "hex.builtin.inspector.long_double", "long double (128 bit)" },
+                { "hex.builtin.inspector.bool", "bool" },
+                { "hex.builtin.inspector.ascii", "ASCII Character" },
+                { "hex.builtin.inspector.wide", "Wide Character" },
+                { "hex.builtin.inspector.utf8", "UTF-8 code point" },
+                { "hex.builtin.inspector.string", "String" },
+                { "hex.builtin.inspector.time32", "time32_t" },
+                { "hex.builtin.inspector.time64", "time64_t" },
+                { "hex.builtin.inspector.time", "time_t" },
+                { "hex.builtin.inspector.dos_date", "DOS Date" },
+                { "hex.builtin.inspector.dos_time", "DOS Time" },
+                { "hex.builtin.inspector.guid", "GUID" },
+                { "hex.builtin.inspector.rgba8", "RGBA8 color" },
+
+                { "hex.builtin.nodes.common.input", "Input" },
+                { "hex.builtin.nodes.common.input.a", "Input A" },
+                { "hex.builtin.nodes.common.input.b", "Input B" },
+                { "hex.builtin.nodes.common.output", "Output" },
+
+                { "hex.builtin.nodes.constants", "Constants" },
+                    { "hex.builtin.nodes.constants.int", "Integer" },
+                        { "hex.builtin.nodes.constants.int.header", "Integer" },
+                    { "hex.builtin.nodes.constants.float", "Float" },
+                        { "hex.builtin.nodes.constants.float.header", "Float" },
+                    { "hex.builtin.nodes.constants.nullptr", "Nullptr" },
+                        { "hex.builtin.nodes.constants.nullptr.header", "Nullptr" },
+                    { "hex.builtin.nodes.constants.buffer", "Buffer" },
+                        { "hex.builtin.nodes.constants.buffer.header", "Buffer" },
+                        { "hex.builtin.nodes.constants.buffer.size", "Size" },
+                    { "hex.builtin.nodes.constants.string", "String" },
+                        { "hex.builtin.nodes.constants.string.header", "String" },
+                    { "hex.builtin.nodes.constants.rgba8", "RGBA8 color" },
+                        { "hex.builtin.nodes.constants.rgba8.header", "RGBA8 color" },
+                        { "hex.builtin.nodes.constants.rgba8.output.r", "Red" },
+                        { "hex.builtin.nodes.constants.rgba8.output.g", "Green" },
+                        { "hex.builtin.nodes.constants.rgba8.output.b", "Blue" },
+                        { "hex.builtin.nodes.constants.rgba8.output.a", "Alpha" },
+                    { "hex.builtin.nodes.constants.comment", "Comment" },
+                        { "hex.builtin.nodes.constants.comment.header", "Comment" },
+
+                { "hex.builtin.nodes.display", "Display" },
+                    { "hex.builtin.nodes.display.int", "Integer" },
+                        { "hex.builtin.nodes.display.int.header", "Integer display" },
+                        { "hex.builtin.nodes.display.int.input", "Value" },
+                    { "hex.builtin.nodes.display.float", "Float" },
+                        { "hex.builtin.nodes.display.float.header", "Float display" },
+                        { "hex.builtin.nodes.display.float.input", "Value" },
+
+                { "hex.builtin.nodes.data_access", "Acesso de dados" },
+                    { "hex.builtin.nodes.data_access.read", "Ler" },
+                        { "hex.builtin.nodes.data_access.read.header", "Ler" },
+                        { "hex.builtin.nodes.data_access.read.address", "Caminho" },
+                        { "hex.builtin.nodes.data_access.read.size", "Tamanho" },
+                        { "hex.builtin.nodes.data_access.read.data", "Dados" },
+                    { "hex.builtin.nodes.data_access.write", "Escrever" },
+                        { "hex.builtin.nodes.data_access.write.header", "Escrever" },
+                        { "hex.builtin.nodes.data_access.write.address", "Caminho" },
+                        { "hex.builtin.nodes.data_access.write.data", "Dados" },
+                    { "hex.builtin.nodes.data_access.size", "Tamanho dos Dados"},
+                        { "hex.builtin.nodes.data_access.size.header", "Tamanho dos Dados"},
+                        { "hex.builtin.nodes.data_access.size.size", "Tamanho"},
+                    { "hex.builtin.nodes.data_access.selection", "Região Selecionada"},
+                        { "hex.builtin.nodes.data_access.selection.header", "Região Selecionada"},
+                        { "hex.builtin.nodes.data_access.selection.address", "Caminho"},
+                        { "hex.builtin.nodes.data_access.selection.size", "Tamanho"},
+
+                { "hex.builtin.nodes.casting", "Conversão de Dados" },
+                    { "hex.builtin.nodes.casting.int_to_buffer", "Integer to Buffer" },
+                        { "hex.builtin.nodes.casting.int_to_buffer.header", "Integer to Buffer" },
+                { "hex.builtin.nodes.casting.buffer_to_int", "Buffer to Integer" },
+                        { "hex.builtin.nodes.casting.buffer_to_int.header", "Buffer to Integer" },
+
+                { "hex.builtin.nodes.arithmetic", "Aritmética" },
+                    { "hex.builtin.nodes.arithmetic.add", "Adição" },
+                        { "hex.builtin.nodes.arithmetic.add.header", "Adicionar" },
+                    { "hex.builtin.nodes.arithmetic.sub", "Subtração" },
+                        { "hex.builtin.nodes.arithmetic.sub.header", "Subtrair" },
+                    { "hex.builtin.nodes.arithmetic.mul", "Multiplição" },
+                        { "hex.builtin.nodes.arithmetic.mul.header", "Multiplicar" },
+                    { "hex.builtin.nodes.arithmetic.div", "Divisão" },
+                        { "hex.builtin.nodes.arithmetic.div.header", "Dividir" },
+                    { "hex.builtin.nodes.arithmetic.mod", "Módulos" },
+                        { "hex.builtin.nodes.arithmetic.mod.header", "Módulo" },
+
+                { "hex.builtin.nodes.buffer", "Buffer" },
+                    { "hex.builtin.nodes.buffer.combine", "Combinar" },
+                        { "hex.builtin.nodes.buffer.combine.header", "Combinar buffers" },
+                    { "hex.builtin.nodes.buffer.slice", "Slice" },
+                        { "hex.builtin.nodes.buffer.slice.header", "Slice buffer" },
+                        { "hex.builtin.nodes.buffer.slice.input.buffer", "Entrada" },
+                        { "hex.builtin.nodes.buffer.slice.input.from", "Do" },
+                        { "hex.builtin.nodes.buffer.slice.input.to", "Para" },
+                    { "hex.builtin.nodes.buffer.repeat", "Repetir" },
+                        { "hex.builtin.nodes.buffer.repeat.header", "Repetir buffer" },
+                        { "hex.builtin.nodes.buffer.repeat.input.count", "Contar" },
+
+                { "hex.builtin.nodes.control_flow", "Control flow" },
+                    { "hex.builtin.nodes.control_flow.if", "If" },
+                        { "hex.builtin.nodes.control_flow.if.header", "If" },
+                        { "hex.builtin.nodes.control_flow.if.condition", "Condition" },
+                        { "hex.builtin.nodes.control_flow.if.true", "True" },
+                        { "hex.builtin.nodes.control_flow.if.false", "False" },
+                    { "hex.builtin.nodes.control_flow.equals", "Equals" },
+                        { "hex.builtin.nodes.control_flow.equals.header", "Equals" },
+                    { "hex.builtin.nodes.control_flow.not", "Not" },
+                        { "hex.builtin.nodes.control_flow.not.header", "Not" },
+                    { "hex.builtin.nodes.control_flow.gt", "Greater than" },
+                        { "hex.builtin.nodes.control_flow.gt.header", "Greater than" },
+                    { "hex.builtin.nodes.control_flow.lt", "Less than" },
+                        { "hex.builtin.nodes.control_flow.lt.header", "Less than" },
+                    { "hex.builtin.nodes.control_flow.and", "AND" },
+                        { "hex.builtin.nodes.control_flow.and.header", "Boolean AND" },
+                    { "hex.builtin.nodes.control_flow.or", "OR" },
+                        { "hex.builtin.nodes.control_flow.or.header", "Boolean OR" },
+
+                { "hex.builtin.nodes.bitwise", "Bitwise operations" },
+                    { "hex.builtin.nodes.bitwise.and", "AND" },
+                        { "hex.builtin.nodes.bitwise.and.header", "Bitwise AND" },
+                    { "hex.builtin.nodes.bitwise.or", "OR" },
+                        { "hex.builtin.nodes.bitwise.or.header", "Bitwise OR" },
+                    { "hex.builtin.nodes.bitwise.xor", "XOR" },
+                        { "hex.builtin.nodes.bitwise.xor.header", "Bitwise XOR" },
+                    { "hex.builtin.nodes.bitwise.not", "NOT" },
+                        { "hex.builtin.nodes.bitwise.not.header", "Bitwise NOT" },
+
+                { "hex.builtin.nodes.decoding", "Decoding" },
+                    { "hex.builtin.nodes.decoding.base64", "Base64" },
+                        { "hex.builtin.nodes.decoding.base64.header", "Base64 decoder" },
+                    { "hex.builtin.nodes.decoding.hex", "Hexadecimal" },
+                        { "hex.builtin.nodes.decoding.hex.header", "Hexadecimal decoder" },
+
+                { "hex.builtin.nodes.crypto", "Cryptography" },
+                    { "hex.builtin.nodes.crypto.aes", "AES Decryptor" },
+                        { "hex.builtin.nodes.crypto.aes.header", "AES Decryptor" },
+                        { "hex.builtin.nodes.crypto.aes.key", "Key" },
+                        { "hex.builtin.nodes.crypto.aes.iv", "IV" },
+                        { "hex.builtin.nodes.crypto.aes.nonce", "Nonce" },
+                        { "hex.builtin.nodes.crypto.aes.mode", "Mode" },
+                        { "hex.builtin.nodes.crypto.aes.key_length", "Key length" },
+
+                { "hex.builtin.nodes.visualizer", "Visualizers" },
+                    { "hex.builtin.nodes.visualizer.digram", "Digram" },
+                        { "hex.builtin.nodes.visualizer.digram.header", "Digram" },
+                    { "hex.builtin.nodes.visualizer.layered_dist", "Layered Distribution" },
+                        { "hex.builtin.nodes.visualizer.layered_dist.header", "Layered Distribution" },
+                    { "hex.builtin.nodes.visualizer.image", "Image" },
+                        { "hex.builtin.nodes.visualizer.image.header", "Image Visualizer" },
+                    { "hex.builtin.nodes.visualizer.byte_distribution", "Byte Distribution" },
+                        { "hex.builtin.nodes.visualizer.byte_distribution.header", "Byte Distribution" },
+
+
+                { "hex.builtin.tools.demangler", "Itanium/MSVC demangler" },
+                    { "hex.builtin.tools.demangler.mangled", "Mangled name" },
+                    { "hex.builtin.tools.demangler.demangled", "Demangled name" },
+                { "hex.builtin.tools.ascii_table", "ASCII table" },
+                    { "hex.builtin.tools.ascii_table.octal", "Mostrar octal" },
+                { "hex.builtin.tools.regex_replacer", "Regex replacer" },
+                    { "hex.builtin.tools.regex_replacer.pattern", "Regex pattern" },
+                    { "hex.builtin.tools.regex_replacer.replace", "Replace pattern" },
+                    { "hex.builtin.tools.regex_replacer.input", "Entrada" },
+                    { "hex.builtin.tools.regex_replacer.output", "Saida" },
+                { "hex.builtin.tools.color", "Color picker" },
+                { "hex.builtin.tools.calc", "Calculadora" },
+                    { "hex.builtin.tools.input", "Input" },
+                    { "hex.builtin.tools.format.standard", "Standard" },
+                    { "hex.builtin.tools.format.scientific", "Scientific" },
+                    { "hex.builtin.tools.format.engineering", "Engineering" },
+                    { "hex.builtin.tools.format.programmer", "Programmer" },
+                    { "hex.builtin.tools.error", "Last error: '{0}'" },
+                    { "hex.builtin.tools.history", "History" },
+                    { "hex.builtin.tools.name", "Nome" },
+                    { "hex.builtin.tools.value", "Valor" },
+                { "hex.builtin.tools.base_converter", "Base converter" },
+                    { "hex.builtin.tools.base_converter.dec", "DEC" },
+                    { "hex.builtin.tools.base_converter.hex", "HEX" },
+                    { "hex.builtin.tools.base_converter.oct", "OCT" },
+                    { "hex.builtin.tools.base_converter.bin", "BIN" },
+                { "hex.builtin.tools.permissions", "Calculadora de Permissões UNIX" },
+                    { "hex.builtin.tools.permissions.perm_bits", "Permission bits" },
+                    { "hex.builtin.tools.permissions.absolute", "Absolute Notation" },
+                    { "hex.builtin.tools.permissions.setuid_error", "O usuário deve ter direitos de execução para que o bit setuid seja aplicado!" },
+                    { "hex.builtin.tools.permissions.setgid_error", "O grupo deve ter direitos de execução para que o bit setgid seja aplicado!" },
+                    { "hex.builtin.tools.permissions.sticky_error", "Outros devem ter direitos de execução para que o sticky bit seja aplicado!" },
+                { "hex.builtin.tools.file_uploader", "Carregador de Arquivo" },
+                    { "hex.builtin.tools.file_uploader.control", "Controle" },
+                    { "hex.builtin.tools.file_uploader.upload", "Enviar" },
+                    { "hex.builtin.tools.file_uploader.done", "Feito!" },
+                    { "hex.builtin.tools.file_uploader.recent", "Recent Uploads" },
+                    { "hex.builtin.tools.file_uploader.tooltip", "Clique para copiar\nCTRL + Click para abrir" },
+                    { "hex.builtin.tools.file_uploader.invalid_response", "Invalid response from Anonfiles!" },
+                    { "hex.builtin.tools.file_uploader.error", "Failed to upload file!\n\nError Code: {0}" },
+                { "hex.builtin.tools.wiki_explain", "Definições de termos da Wikipédia" },
+                    { "hex.builtin.tools.wiki_explain.control", "Control" },
+                    { "hex.builtin.tools.wiki_explain.search", "Procurar" },
+                    { "hex.builtin.tools.wiki_explain.results", "Resultados" },
+                    { "hex.builtin.tools.wiki_explain.invalid_response", "Resposta inválida da Wikipedia!" },
+                { "hex.builtin.tools.file_tools", "Ferramentas de Arquivo" },
+                    { "hex.builtin.tools.file_tools.shredder", "Triturador" },
+                        { "hex.builtin.tools.file_tools.shredder.warning", "Esta ferramenta destrói IRRECUPERAVELMENTE um arquivo. Use com cuidado" },
+                        { "hex.builtin.tools.file_tools.shredder.input", "Arquivo para triturar " },
+                        { "hex.builtin.tools.file_tools.shredder.picker", "Abrir arquivo para triturar" },
+                        { "hex.builtin.tools.file_tools.shredder.fast", "Modo Rápido" },
+                        { "hex.builtin.tools.file_tools.shredder.shredding", "Triturando..." },
+                        { "hex.builtin.tools.file_tools.shredder.shred", "Triturado" },
+                        { "hex.builtin.tools.file_tools.shredder.error.open", "Falha ao abrir o arquivo selecionado!" },
+                        { "hex.builtin.tools.file_tools.shredder.success", "Triturado com sucesso!" },
+                    { "hex.builtin.tools.file_tools.splitter", "Divisor" },
+                        { "hex.builtin.tools.file_tools.splitter.sizes.5_75_floppy", "5¼\" Floppy disk (1200KiB)" },
+                        { "hex.builtin.tools.file_tools.splitter.sizes.3_5_floppy", "3½\" Floppy disk (1400KiB)" },
+                        { "hex.builtin.tools.file_tools.splitter.sizes.zip100", "Zip 100 Disk (100MiB)" },
+                        { "hex.builtin.tools.file_tools.splitter.sizes.zip200", "Zip 200 Disk (200MiB)" },
+                        { "hex.builtin.tools.file_tools.splitter.sizes.cdrom650", "CD-ROM (650MiB)" },
+                        { "hex.builtin.tools.file_tools.splitter.sizes.cdrom700", "CD-ROM (700MiB)" },
+                        { "hex.builtin.tools.file_tools.splitter.sizes.fat32", "FAT32 (4GiB)" },
+                        { "hex.builtin.tools.file_tools.splitter.sizes.custom", "Customizado" },
+                        { "hex.builtin.tools.file_tools.splitter.input", "Arquivo para dividir " },
+                        { "hex.builtin.tools.file_tools.splitter.picker.input", "Abrir arquivo para dividir" },
+                        { "hex.builtin.tools.file_tools.splitter.output", "Caminho de Saída " },
+                        { "hex.builtin.tools.file_tools.splitter.picker.output", "Definir caminho base" },
+                        { "hex.builtin.tools.file_tools.splitter.picker.splitting", "Dividindo..." },
+                        { "hex.builtin.tools.file_tools.splitter.picker.split", "Dividir" },
+                        { "hex.builtin.tools.file_tools.splitter.picker.error.open", "Falha ao abrir o arquivo selecionado!" },
+                        { "hex.builtin.tools.file_tools.splitter.picker.error.size", "O arquivo é menor que o tamanho da peça" },
+                        { "hex.builtin.tools.file_tools.splitter.picker.error.create", "Falha ao criar arquivo de peça {0}" },
+                        { "hex.builtin.tools.file_tools.splitter.picker.success", "Arquivo dividido com sucesso!" },
+                    { "hex.builtin.tools.file_tools.combiner", "Combinador" },
+                        { "hex.builtin.tools.file_tools.combiner.add", "Adicionar..." },
+                        { "hex.builtin.tools.file_tools.combiner.add.picker", "Adicionar Arquivo" },
+                        { "hex.builtin.tools.file_tools.combiner.delete", "Apagar" },
+                        { "hex.builtin.tools.file_tools.combiner.clear", "Limpar" },
+                        { "hex.builtin.tools.file_tools.combiner.output", "Arquivo de saída" },
+                        { "hex.builtin.tools.file_tools.combiner.output.picker", "Definir caminho base de saída" },
+                        { "hex.builtin.tools.file_tools.combiner.combining", "Combinando..." },
+                        { "hex.builtin.tools.file_tools.combiner.combine", "Combinar" },
+                        { "hex.builtin.tools.file_tools.combiner.error.open_output", "Falha ao criar um Arquivo de saída" },
+                        { "hex.builtin.tools.file_tools.combiner.open_input", "Falha ao abrir o Arquivo de saída {0}" },
+                        { "hex.builtin.tools.file_tools.combiner.success", "Arquivos combinados com sucesso!" },
+                { "hex.builtin.tools.ieee756", "IEEE 756 Floating Point Tester" },
+                    { "hex.builtin.tools.ieee756.sign", "Sign" },
+                    { "hex.builtin.tools.ieee756.exponent", "Exponent" },
+                    { "hex.builtin.tools.ieee756.mantissa", "Mantissa" },
+                    { "hex.builtin.tools.ieee756.exponent_size", "Exponent Size" },
+                    { "hex.builtin.tools.ieee756.mantissa_size", "Mantissa Size" },
+                    { "hex.builtin.tools.ieee756.half_precision", "Half Precision" },
+                    { "hex.builtin.tools.ieee756.singe_precision", "Single Precision" },
+                    { "hex.builtin.tools.ieee756.double_precision", "Double Precision" },
+                    { "hex.builtin.tools.ieee756.type", "Tipo" },
+                    { "hex.builtin.tools.ieee756.formula", "Formula" },
+                    { "hex.builtin.tools.ieee756.result.title", "Resultado" },
+                    { "hex.builtin.tools.ieee756.result.float", "Resultado de ponto flutuante" },
+                    { "hex.builtin.tools.ieee756.result.hex", "Resultado Hexadecimal" },
+
+                { "hex.builtin.setting.imhex", "ImHex" },
+                    { "hex.builtin.setting.imhex.recent_files", "Arquivos Recentes" },
+                { "hex.builtin.setting.general", "General" },
+                    { "hex.builtin.setting.general.show_tips", "Mostrar dicas na inicialização" },
+                    { "hex.builtin.setting.general.auto_load_patterns", "Padrão compatível com carregamento automático" },
+                { "hex.builtin.setting.interface", "Interface" },
+                    { "hex.builtin.setting.interface.color", "Color theme" },
+                        { "hex.builtin.setting.interface.color.system", "Sistema" },
+                        { "hex.builtin.setting.interface.color.dark", "Escuro" },
+                        { "hex.builtin.setting.interface.color.light", "Claro" },
+                        { "hex.builtin.setting.interface.color.classic", "Classico" },
+                    { "hex.builtin.setting.interface.scaling", "Scaling" },
+                        { "hex.builtin.setting.interface.scaling.native", "Nativo" },
+                        { "hex.builtin.setting.interface.scaling.x0_5", "x0.5" },
+                        { "hex.builtin.setting.interface.scaling.x1_0", "x1.0" },
+                        { "hex.builtin.setting.interface.scaling.x1_5", "x1.5" },
+                        { "hex.builtin.setting.interface.scaling.x2_0", "x2.0" },
+                    { "hex.builtin.setting.interface.language", "Idioma" },
+                    { "hex.builtin.setting.interface.wiki_explain_language", "Idioma do Wikipedia" },
+                    { "hex.builtin.setting.interface.fps", "FPS Limit" },
+                    { "hex.builtin.setting.interface.fps.unlocked", "Destravado" },
+                { "hex.builtin.setting.hex_editor", "Hex Editor" },
+                    { "hex.builtin.setting.hex_editor.highlight_color", "Selection highlight color" },
+                    { "hex.builtin.setting.hex_editor.bytes_per_row", "Bytes por linha" },
+                    { "hex.builtin.setting.hex_editor.ascii", "Exibir coluna ASCII" },
+                    { "hex.builtin.setting.hex_editor.advanced_decoding", "Display advanced decoding column" },
+                    { "hex.builtin.setting.hex_editor.grey_zeros", "Grey out zeros" },
+                    { "hex.builtin.setting.hex_editor.uppercase_hex", "Upper case Hex characters" },
+                    { "hex.builtin.setting.hex_editor.visualizer", "Visualizador de Dados" },
+                { "hex.builtin.setting.folders", "Pastas" },
+                    { "hex.builtin.setting.folders.description", "Especifique caminhos de pesquisa adicionais para padrões, scripts, regras Yara e muito mais" },
+                    { "hex.builtin.setting.folders.add_folder", "Adicionar nova pasta" },
+                    { "hex.builtin.setting.folders.remove_folder", "Remover a pasta atualmente selecionada da lista" },
+                { "hex.builtin.setting.font", "Fonte" },
+                    { "hex.builtin.setting.font.font_path", "Caminho da Fonte Customizada" },
+                    { "hex.builtin.setting.font.font_size", "Tamanho da Fonte" },
+
+                { "hex.builtin.provider.file.path", "Caminho do Arquivo" },
+                { "hex.builtin.provider.file.size", "Tamanho" },
+                { "hex.builtin.provider.file.creation", "Data de Criação" },
+                { "hex.builtin.provider.file.access", "Ultima vez acessado" },
+                { "hex.builtin.provider.file.modification", "Ultima vez modificado" },
+
+                { "hex.builtin.provider.file", "Provedor de arquivo" },
+                { "hex.builtin.provider.gdb", "GDB Server Provider" },
+                    { "hex.builtin.provider.gdb.name", "GDB Server <{0}:{1}>" },
+                    { "hex.builtin.provider.gdb.server", "Servidor" },
+                    { "hex.builtin.provider.gdb.ip", "Endereço de IP" },
+                    { "hex.builtin.provider.gdb.port", "Porta" },
+                { "hex.builtin.provider.disk", "Provedor de disco bruto" },
+                    { "hex.builtin.provider.disk.selected_disk", "Disco" },
+                    { "hex.builtin.provider.disk.disk_size", "Tamanho do Disco" },
+                    { "hex.builtin.provider.disk.sector_size", "Tamanho do Setor" },
+                    { "hex.builtin.provider.disk.reload", "Recarregar" },
+
+                { "hex.builtin.layouts.default", "Default" },
+
+                { "hex.builtin.visualizer.hexadecimal.8bit", "Hexadecimal (8 bits)" },
+                { "hex.builtin.visualizer.hexadecimal.16bit", "Hexadecimal (16 bits)" },
+                { "hex.builtin.visualizer.hexadecimal.32bit", "Hexadecimal (32 bits)" },
+                { "hex.builtin.visualizer.hexadecimal.64bit", "Hexadecimal (64 bits)" },
+                { "hex.builtin.visualizer.decimal.signed.8bit", "Decimal Signed (8 bits)" },
+                { "hex.builtin.visualizer.decimal.signed.16bit", "Decimal Signed (16 bits)" },
+                { "hex.builtin.visualizer.decimal.signed.32bit", "Decimal Signed (32 bits)" },
+                { "hex.builtin.visualizer.decimal.signed.64bit", "Decimal Signed (64 bits)" },
+                { "hex.builtin.visualizer.decimal.unsigned.8bit", "Decimal Unsigned (8 bits)" },
+                { "hex.builtin.visualizer.decimal.unsigned.16bit", "Decimal Unsigned (16 bits)" },
+                { "hex.builtin.visualizer.decimal.unsigned.32bit", "Decimal Unsigned (32 bits)" },
+                { "hex.builtin.visualizer.decimal.unsigned.64bit", "Decimal Unsigned (64 bits)" },
+                { "hex.builtin.visualizer.floating_point.32bit", "Floating Point (32 bits)" },
+                { "hex.builtin.visualizer.floating_point.64bit", "Floating Point (64 bits)" },
+                { "hex.builtin.visualizer.hexii", "HexII" },
+                { "hex.builtin.visualizer.rgba8", "RGBA8 Color" },
+
+                { "hex.builtin.hash.md5", "MD5" },
+                { "hex.builtin.hash.sha1", "SHA1" },
+                { "hex.builtin.hash.sha224", "SHA224" },
+                { "hex.builtin.hash.sha256", "SHA256" },
+                { "hex.builtin.hash.sha384", "SHA384" },
+                { "hex.builtin.hash.sha512", "SHA512" },
+                { "hex.builtin.hash.crc8", "CRC8" },
+                { "hex.builtin.hash.crc16", "CRC16" },
+                { "hex.builtin.hash.crc32", "CRC32" },
+                    { "hex.builtin.hash.crc.poly", "Polynomial" },
+                    { "hex.builtin.hash.crc.iv", "Initial Value" },
+                    { "hex.builtin.hash.crc.xor_out", "XOR Out" },
+                    { "hex.builtin.hash.crc.refl_in", "Reflect In" },
+                    { "hex.builtin.hash.crc.refl_out", "Reflect Out" },
+        });
+    }
+
+}

plugins/builtin/source/lang/zh_CN.cpp

@@ -216,11 +216,15 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.view.disassembler.disassembly.bytes", "字节" },
 
                 { "hex.builtin.view.hashes.name", "哈希" },
-                    { "hex.builtin.view.hashes.settings", "设置" },
+                    //{ "hex.builtin.view.hashes.hash", "Hash" },
+                    //{ "hex.builtin.view.hashes.no_settings", "No settings available" },
                     { "hex.builtin.view.hashes.function", "哈希函数" },
-                    { "hex.builtin.view.hashes.iv", "初始值" },
-                    { "hex.builtin.view.hashes.poly", "多项式" },
+                    //{ "hex.builtin.view.hashes.name", "Name" },
+                    //{ "hex.builtin.view.hashes.type", "Type" },
                     { "hex.builtin.view.hashes.result", "结果" },
+                    //{ "hex.builtin.view.hashes.remove", "Remove hash" },
+                    //{ "hex.builtin.view.hashes.hover_info", "Hover over the Hex Editor selection and hold down SHIFT to view the hashes of that region." },
+
 
                 { "hex.builtin.view.help.name", "帮助" },
                     { "hex.builtin.view.help.about.name", "关于" },
@@ -639,6 +643,20 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.tools.file_tools.combiner.error.open_output", "创建输出文件失败！" },
                         { "hex.builtin.tools.file_tools.combiner.open_input", "打开输入文件 {0} 失败" },
                         { "hex.builtin.tools.file_tools.combiner.success", "文件合并成功！" },
+                    //{ "hex.builtin.tools.ieee756", "IEEE 756 Floating Point Tester" },
+                        //{ "hex.builtin.tools.ieee756.sign", "Sign" },
+                        //{ "hex.builtin.tools.ieee756.exponent", "Exponent" },
+                        //{ "hex.builtin.tools.ieee756.mantissa", "Mantissa" },
+                        //{ "hex.builtin.tools.ieee756.exponent_size", "Exponent Size" },
+                        //{ "hex.builtin.tools.ieee756.mantissa_size", "Mantissa Size" },
+                        //{ "hex.builtin.tools.ieee756.half_precision", "Half Precision" },
+                        //{ "hex.builtin.tools.ieee756.singe_precision", "Single Precision" },
+                        //{ "hex.builtin.tools.ieee756.double_precision", "Double Precision" },
+                        //{ "hex.builtin.tools.ieee756.type", "Type" },
+                        //{ "hex.builtin.tools.ieee756.formula", "Formula" },
+                        //{ "hex.builtin.tools.ieee756.result.title", "Result" },
+                        //{ "hex.builtin.tools.ieee756.result.float", "Floating Point Result" },
+                        //{ "hex.builtin.tools.ieee756.result.hex", "Hexadecimal Result" },
 
                 { "hex.builtin.setting.imhex", "ImHex" },
                     { "hex.builtin.setting.imhex.recent_files", "最近文件" },
@@ -713,6 +731,21 @@ namespace hex::plugin::builtin {
                 //{ "hex.builtin.visualizer.floating_point.64bit", "Floating Point (64 bits)" },
                 //{ "hex.builtin.visualizer.hexii", "HexII" },
                 //{ "hex.builtin.visualizer.rgba8", "RGBA8 Color" },
+
+                { "hex.builtin.hash.md5", "MD5" },
+                { "hex.builtin.hash.sha1", "SHA1" },
+                { "hex.builtin.hash.sha224", "SHA224" },
+                { "hex.builtin.hash.sha256", "SHA256" },
+                { "hex.builtin.hash.sha384", "SHA384" },
+                { "hex.builtin.hash.sha512", "SHA512" },
+                { "hex.builtin.hash.crc8", "CRC8" },
+                { "hex.builtin.hash.crc16", "CRC16" },
+                { "hex.builtin.hash.crc32", "CRC32" },
+                    { "hex.builtin.hash.crc.poly", "多项式" },
+                    { "hex.builtin.hash.crc.iv", "初始值" },
+                    //{ "hex.builtin.hash.crc.xor_out", "XOR Out" },
+                    //{ "hex.builtin.hash.crc.refl_in", "Reflect In" },
+                    //{ "hex.builtin.hash.crc.refl_out", "Reflect Out" },
         });
     }
 

plugins/builtin/source/plugin_builtin.cpp

@@ -11,6 +11,7 @@ namespace hex::plugin::builtin {
     void registerCommandPaletteCommands();
     void registerSettings();
     void registerDataProcessorNodes();
+    void registerHashes();
     void registerProviders();
     void registerDataFormatters();
     void registerLayouts();
@@ -27,6 +28,7 @@ namespace hex::plugin::builtin {
     void registerLanguageItIT();
     void registerLanguageJaJP();
     void registerLanguageZhCN();
+    void registerLanguagePtBR();
 
 }
 
@@ -39,6 +41,7 @@ IMHEX_PLUGIN_SETUP("Built-in", "WerWolv", "Default ImHex functionality") {
     registerLanguageItIT();
     registerLanguageJaJP();
     registerLanguageZhCN();
+    registerLanguagePtBR();
 
     registerEventHandlers();
     registerDataVisualizers();
@@ -49,6 +52,7 @@ IMHEX_PLUGIN_SETUP("Built-in", "WerWolv", "Default ImHex functionality") {
     registerCommandPaletteCommands();
     registerSettings();
     registerDataProcessorNodes();
+    registerHashes();
     registerProviders();
     registerDataFormatters();
     createWelcomeScreen();

plugins/windows/CMakeLists.txt

@@ -14,6 +14,7 @@ if (WIN32)
             source/lang/en_US.cpp
             source/lang/de_DE.cpp
             source/lang/zh_CN.cpp
+            source/lang/pt_BR.cpp
 
             source/content/ui_items.cpp
             source/content/settings_entries.cpp

plugins/windows/source/lang/pt_BR.cpp

@@ -0,0 +1,35 @@
+#include <hex/api/content_registry.hpp>
+#include <hex/api/localization.hpp>
+
+namespace hex::plugin::windows {
+
+    void registerLanguagePtBR() {
+        ContentRegistry::Language::addLocalizations("pt-BR", {
+            { "hex.windows.title_bar_button.feedback", "Deixar Feedback" },
+            { "hex.windows.title_bar_button.debug_build", "Compilação de depuração"},
+
+            { "hex.windows.view.tty_console.name", "TTY Console" },
+                { "hex.windows.view.tty_console.config", "Configuração"},
+                    { "hex.windows.view.tty_console.port", "Porta" },
+                    { "hex.windows.view.tty_console.reload", "Recarregar" },
+                    { "hex.windows.view.tty_console.baud", "Baud rate" },
+                    { "hex.windows.view.tty_console.num_bits", "Data bits" },
+                    { "hex.windows.view.tty_console.stop_bits", "Stop bits" },
+                    { "hex.windows.view.tty_console.parity_bits", "Parity bit" },
+                    { "hex.windows.view.tty_console.cts", "Usar o controle de fluxo CTS" },
+                    { "hex.windows.view.tty_console.connect", "Conectar" },
+                    { "hex.windows.view.tty_console.disconnect", "Desconectar" },
+                    { "hex.windows.view.tty_console.connect_error", "Falha ao conectar à porta COM!" },
+                    { "hex.windows.view.tty_console.no_available_port", "Nenhuma porta COM válida está selecionada ou nenhuma porta COM está disponível!" },
+                    { "hex.windows.view.tty_console.clear", "Limpar" },
+                    { "hex.windows.view.tty_console.auto_scroll", "Auto rolagem" },
+                { "hex.windows.view.tty_console.console", "Console" },
+                    { "hex.windows.view.tty_console.send_etx", "Enviar ETX" },
+                    { "hex.windows.view.tty_console.send_eot", "Enviar EOT" },
+                    { "hex.windows.view.tty_console.send_sub", "Enviar SUB" },
+
+                    { "hex.builtin.setting.general.context_menu_entry", "Entrada do menu de contexto do Windows" },
+        });
+    }
+
+}

plugins/windows/source/plugin_windows.cpp

@@ -13,6 +13,7 @@ namespace hex::plugin::windows {
     void registerLanguageEnUS();
     void registerLanguageDeDE();
     void registerLanguageZhCN();
+    void registerLanguagePtBR();
 
     void addFooterItems();
     void addTitleBarButtons();
@@ -56,6 +57,7 @@ IMHEX_PLUGIN_SETUP("Windows", "WerWolv", "Windows-only features") {
     registerLanguageEnUS();
     registerLanguageDeDE();
     registerLanguageZhCN();
+    registerLanguagePtBR();
 
     hex::ContentRegistry::Views::add<ViewTTYConsole>();