build: Bumped version to 1.19.2

Fixes #576

.github/workflows/release.yml

@@ -32,7 +32,7 @@ jobs:
           echo "version=$project_version" >> $GITHUB_ENV
 
       - name: 🗜️ Create tarball from sources with dependencies
-        run: tar -cvf Full.Sources.tar.gz ImHex
+        run: tar --exclude-vcs -czvf Full.Sources.tar.gz ImHex
         
       - name: ⬇️ Download artifacts from latest workflow
         uses: dawidd6/action-download-artifact@v2
@@ -90,3 +90,12 @@ jobs:
           ssh_private_key: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
           commit_message: Bump to version ${{env.version}}
           ssh_keyscan_types: rsa,dsa,ecdsa,ed25519
+
+      - uses: ncipollo/release-action@v1
+        env:
+          MY_KEY: ${{ secrets.RELEASE_TOKEN }}
+        if: "${{ env.MY_KEY != '' }}"
+        with:
+          tag: ImHex-v${{env.version}}
+          repo: PatternLanguage
+          token: ${{ secrets.RELEASE_TOKEN }}

CMakeLists.txt

@@ -5,11 +5,13 @@ file(READ "VERSION" IMHEX_VERSION)
 project(imhex VERSION ${IMHEX_VERSION})
 message("Project version ${IMHEX_VERSION}")
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(IMHEX_BASE_FOLDER ${CMAKE_CURRENT_SOURCE_DIR})
 set(CMAKE_MODULE_PATH "${IMHEX_BASE_FOLDER}/cmake/modules")
 include("${IMHEX_BASE_FOLDER}/cmake/build_helpers.cmake")
 
+option(IMHEX_OFFLINE_BUILD "Enable offline build" OFF)
+
 # Make sure project is configured correctly
 setDefaultBuiltTypeIfUnset()
 detectBadClone()

README.md

@@ -122,13 +122,14 @@ To develop plugins for ImHex, use one of the following two templates projects to
 Nightlies are available via GitHub Actions [here](https://github.com/WerWolv/ImHex/actions?query=workflow%3ABuild).
 
 - Windows • __x86_64__
-  - [MSI](https://nightly.link/WerWolv/ImHex/workflows/build/master/Windows%20Installer.zip)
-  - [EXE](https://nightly.link/WerWolv/ImHex/workflows/build/master/Windows%20Portable%20ZIP.zip)
+  - [Installer](https://nightly.link/WerWolv/ImHex/workflows/build/master/Windows%20Installer.zip)
+  - [Portable](https://nightly.link/WerWolv/ImHex/workflows/build/master/Windows%20Portable%20ZIP.zip)
 - MacOS • __x86_64__
   - [DMG](https://nightly.link/WerWolv/ImHex/workflows/build/master/macOS%20DMG.zip)
 - Linux • __x86_64__
   - [DEB](https://nightly.link/WerWolv/ImHex/workflows/build/master/Linux%20DEB.zip)
   - [AppImage](https://nightly.link/WerWolv/ImHex/workflows/build/master/Linux%20AppImage.zip)
+  - [Arch Package](https://nightly.link/WerWolv/ImHex/workflows/build/master/ArchLinux%20.pkg.tar.zst.zip)
 
 ## Compiling
 

VERSION

@@ -1 +1 @@
-1.19.0
+1.19.2

cmake/build_helpers.cmake

@@ -222,6 +222,7 @@ macro(createPackage)
     
         configure_file(${CMAKE_SOURCE_DIR}/dist/DEBIAN/control.in ${CMAKE_BINARY_DIR}/DEBIAN/control)    
     
+        install(FILES ${CMAKE_SOURCE_DIR}/LICENSE DESTINATION ${CMAKE_INSTALL_PREFIX}/share/licenses/imhex)
         install(FILES ${CMAKE_SOURCE_DIR}/dist/imhex.desktop DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications)
         install(FILES ${CMAKE_SOURCE_DIR}/resources/icon.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/pixmaps RENAME imhex.png)
         install(FILES "$<TARGET_FILE:libimhex>" DESTINATION "${CMAKE_INSTALL_LIBDIR}")
@@ -289,17 +290,19 @@ endmacro()
 
 
 function(downloadImHexPatternsFiles dest)
-    FetchContent_Declare(
-        imhex_patterns
-        GIT_REPOSITORY https://github.com/WerWolv/ImHex-Patterns.git
-        GIT_TAG master
-    )
+    if (NOT IMHEX_OFFLINE_BUILD)
+        FetchContent_Declare(
+            imhex_patterns
+            GIT_REPOSITORY https://github.com/WerWolv/ImHex-Patterns.git
+            GIT_TAG master
+        )
 
-    FetchContent_Populate(imhex_patterns)
+        FetchContent_Populate(imhex_patterns)
 
-    set(PATTERNS_FOLDERS_TO_INSTALL constants encodings includes patterns magic)
-    foreach (FOLDER ${PATTERNS_FOLDERS_TO_INSTALL})
-        install(DIRECTORY "${imhex_patterns_SOURCE_DIR}/${FOLDER}" DESTINATION ${dest})
-    endforeach()
+        set(PATTERNS_FOLDERS_TO_INSTALL constants encodings includes patterns magic)
+        foreach (FOLDER ${PATTERNS_FOLDERS_TO_INSTALL})
+            install(DIRECTORY "${imhex_patterns_SOURCE_DIR}/${FOLDER}" DESTINATION ${dest})
+        endforeach ()
+    endif ()
 
 endfunction()

dist/AppImageBuilder.yml

@@ -26,7 +26,6 @@ AppDir:
     - sourceline: deb http://security.ubuntu.com/ubuntu jammy-security universe
     - sourceline: deb http://security.ubuntu.com/ubuntu jammy-security multiverse
     include:
-    - adwaita-icon-theme-full
     - librsvg2-common
     - libbz2-1.0:amd64
     - libcap2:amd64
@@ -85,7 +84,6 @@ AppDir:
     - /lib/x86_64-linux-gnu/libgnutls.so.30
     - /lib/x86_64-linux-gnu/libgobject-2.0.so.0
     - /lib/x86_64-linux-gnu/libgraphite2.so.3
-    - /lib/x86_64-linux-gnu/libgtk-3.so.0
     - /lib/x86_64-linux-gnu/libharfbuzz.so.0
     - /lib/x86_64-linux-gnu/libhogweed.so.6
     - /lib/x86_64-linux-gnu/libicudata.so.70

dist/Arch/PKGBUILD

@@ -8,7 +8,7 @@ url="https://github.com/WerWolv/ImHex"
 repo=$url
 license=('GPL 2.0')
 groups=()
-depends=(glfw mbedtls python freetype2 libglvnd gtk3)
+depends=(glfw mbedtls python freetype2 libglvnd dbus xdg-desktop-portal)
 makedepends=(git)
 checkdepends=()
 optdepends=()
@@ -34,5 +34,6 @@ package() {
     done
 
 	cp -r $srcdir/usr/share/imhex/{constants,encodings,includes,magic,patterns} $pkgdir/usr/share/imhex
-    install -d $pkgdir/usr/share/imhex
+	cp -r $srcdir/usr/share/{applications,licenses} $pkgdir/usr/share
+    install -d $pkgdir/usr/share
 }

dist/DEBIAN/control.in

@@ -4,7 +4,7 @@ Section: editors
 Priority: optional
 Architecture: amd64
 License: GNU GPL-2
-Depends: libglfw3, libmagic1, libmbedtls14, libpython3.10, libfreetype6, libopengl0, libgtk-3-0
+Depends: libglfw3, libmagic1, libmbedtls14, libpython3.10, libfreetype6, libopengl0, libdbus-1-3, xdg-desktop-portal
 Maintainer: WerWolv <hey@werwolv.net>
 Description: ImHex Hex Editor
  A Hex Editor for Reverse Engineers, Programmers and

dist/DEBIAN/imhex.desktop

@@ -1,11 +0,0 @@
-[Desktop Entry]
-Name=ImHex
-Comment=ImHex Hex Editor
-GenericName=Hex Editor
-Exec=/usr/bin/imhex %U
-Icon=/usr/share/pixmaps/imhex.png
-Type=Application
-StartupNotify=true
-Categories=GNOME;GTK;Development;
-StartupWMClass=imhex
-

dist/Dockerfile

@@ -15,7 +15,8 @@ RUN pacman -S --needed --noconfirm      \
     mbedtls                             \
     python3                             \
     freetype2                           \
-    gtk3
+    dbus                                \
+    xdg-desktop-portal
 
 # Clone ImHex
 RUN git clone https://github.com/WerWolv/ImHex --recurse-submodules /root/ImHex

dist/ImHex-9999.ebuild

@@ -27,6 +27,7 @@ RDEPEND="${DEPEND}
 		sys-apps/file
 		dev-libs/mbedtls
 		dev-cpp/nlohmann_json
-		x11-libs/gtk+
+		dbus
+		xdg-desktop-portal
 		"
 BDEPEND="${DEPEND}"

dist/get_deps_archlinux.sh

@@ -9,4 +9,5 @@ pacman -S $@ --needed \
   mbedtls   \
   python3   \
   freetype2 \
-  gtk3
+  dbus      \
+  xdg-desktop-portal

dist/get_deps_debian.sh

@@ -21,4 +21,5 @@ apt install -y \
   libmbedtls-dev        \
   python3-dev           \
   libfreetype-dev       \
-  libgtk-3-dev
+  libdbus-1-dev         \
+  xdg-desktop-portal

dist/get_deps_fedora.sh

@@ -10,4 +10,5 @@ dnf install         \
   mbedtls-devel     \
   python-devel      \
   freetype-devel    \
-  gtk3-devel
+  dbus              \
+  xdg-desktop-portal

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

@@ -44,6 +44,7 @@ namespace hex {
         std::future<Response<void>> downloadFile(const std::string &url, const std::fs::path &filePath, u32 timeout = DefaultTimeout);
 
         [[nodiscard]] std::string encode(const std::string &input);
+        [[nodiscard]] std::string decode(const std::string &input);
 
         [[nodiscard]] float getProgress() const { return this->m_progress; }
 

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

@@ -130,6 +130,7 @@ namespace ImGui {
     }
 
     bool InputText(const char* label, std::string &buffer, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
+    bool InputText(const char *label, std::u8string &buffer, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
     bool InputTextMultiline(const char* label, std::string &buffer, const ImVec2& size = ImVec2(0, 0), ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
 
     bool InputScalarCallback(const char* label, ImGuiDataType data_type, void* p_data, const char* format, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);

lib/libimhex/source/api/plugin_manager.cpp

@@ -24,8 +24,6 @@ namespace hex {
             }
         #endif
 
-        auto pluginName = std::fs::path(path).stem().string();
-
         this->m_initializePluginFunction     = getPluginFunction<InitializePluginFunc>("initializePlugin");
         this->m_getPluginNameFunction        = getPluginFunction<GetPluginNameFunc>("getPluginName");
         this->m_getPluginAuthorFunction      = getPluginFunction<GetPluginAuthorFunc>("getPluginAuthor");

lib/libimhex/source/helpers/encoding_file.cpp

@@ -38,8 +38,6 @@ namespace hex {
             {
                 auto delimiterPos = line.find('=');
 
-                if (delimiterPos == std::string::npos)
-                    continue;
                 if (delimiterPos >= line.length())
                     continue;
 
@@ -47,12 +45,16 @@ namespace hex {
                 to   = line.substr(delimiterPos + 1);
 
                 if (from.empty()) continue;
-                if (to.empty()) to = " ";
             }
 
             auto fromBytes = hex::parseByteString(from);
             if (fromBytes.empty()) continue;
 
+            if (to.length() > 1)
+                hex::trim(to);
+            if (to.empty())
+                to = " ";
+
             if (!this->m_mapping.contains(fromBytes.size()))
                 this->m_mapping.insert({ fromBytes.size(), {} });
             this->m_mapping[fromBytes.size()].insert({ fromBytes, to });

lib/libimhex/source/helpers/fs.cpp

@@ -4,6 +4,7 @@
 #include <hex/helpers/fs_macos.hpp>
 #include <hex/helpers/file.hpp>
 #include <hex/helpers/intrinsics.hpp>
+#include <hex/helpers/net.hpp>
 
 #include <xdg.hpp>
 
@@ -70,7 +71,7 @@ namespace hex::fs {
     bool openFileBrowser(DialogMode mode, const std::vector<nfdfilteritem_t> &validExtensions, const std::function<void(std::fs::path)> &callback, const std::string &defaultPath) {
         NFD::Init();
 
-        nfdchar_t *outPath;
+        nfdchar_t *outPath = nullptr;
         nfdresult_t result;
         switch (mode) {
             case DialogMode::Open:
@@ -86,8 +87,8 @@ namespace hex::fs {
                 hex::unreachable();
         }
 
-        if (result == NFD_OKAY) {
-            callback(reinterpret_cast<const char8_t *>(outPath));
+        if (result == NFD_OKAY && outPath != nullptr) {
+            callback(reinterpret_cast<char8_t*>(outPath));
             NFD::FreePath(outPath);
         }
 
@@ -205,39 +206,39 @@ namespace hex::fs {
 
         switch (path) {
             case ImHexPath::Patterns:
-                result.push_back((applicationSupportDirPath / "patterns").string());
+                result.push_back(applicationSupportDirPath / "patterns");
                 break;
             case ImHexPath::PatternsInclude:
-                result.push_back((applicationSupportDirPath / "includes").string());
+                result.push_back(applicationSupportDirPath / "includes");
                 break;
             case ImHexPath::Magic:
-                result.push_back((applicationSupportDirPath / "magic").string());
+                result.push_back(applicationSupportDirPath / "magic");
                 break;
             case ImHexPath::Python:
-                result.push_back((applicationSupportDirPath / "python").string());
+                result.push_back(applicationSupportDirPath / "python");
                 break;
             case ImHexPath::Plugins:
                 std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
-                    return (path / "plugins").string();
+                    return path / "plugins";
                 });
                 break;
             case ImHexPath::Yara:
-                result.push_back((applicationSupportDirPath / "yara").string());
+                result.push_back(applicationSupportDirPath / "yara");
                 break;
             case ImHexPath::Config:
-                result.push_back((applicationSupportDirPath / "config").string());
+                result.push_back(applicationSupportDirPath / "config");
                 break;
             case ImHexPath::Resources:
-                result.push_back((applicationSupportDirPath / "resources").string());
+                result.push_back(applicationSupportDirPath / "resources");
                 break;
             case ImHexPath::Constants:
-                result.push_back((applicationSupportDirPath / "constants").string());
+                result.push_back(applicationSupportDirPath / "constants");
                 break;
             case ImHexPath::Encodings:
-                result.push_back((applicationSupportDirPath / "encodings").string());
+                result.push_back(applicationSupportDirPath / "encodings");
                 break;
             case ImHexPath::Logs:
-                result.push_back((applicationSupportDirPath / "logs").string());
+                result.push_back(applicationSupportDirPath / "logs");
                 break;
             default:
                 hex::unreachable();
@@ -258,43 +259,43 @@ namespace hex::fs {
         switch (path) {
             case ImHexPath::Patterns:
                 addUserDirs(dataDirs);
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p / "patterns").string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "patterns"; });
                 break;
             case ImHexPath::PatternsInclude:
                 addUserDirs(dataDirs);
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p / "includes").string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "includes"; });
                 break;
             case ImHexPath::Magic:
                 addUserDirs(dataDirs);
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p / "magic").string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "magic"; });
                 break;
             case ImHexPath::Python:
                 addUserDirs(dataDirs);
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p).string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p; });
                 break;
             case ImHexPath::Plugins:
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p / "plugins").string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "plugins"; });
                 break;
             case ImHexPath::Yara:
                 addUserDirs(dataDirs);
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p / "yara").string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "yara"; });
                 break;
             case ImHexPath::Config:
-                std::transform(configDirs.begin(), configDirs.end(), std::back_inserter(result), [](auto p) { return (p / "imhex").string(); });
+                std::transform(configDirs.begin(), configDirs.end(), std::back_inserter(result), [](auto p) { return p / "imhex"; });
                 break;
             case ImHexPath::Resources:
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p / "resources").string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "resources"; });
                 break;
             case ImHexPath::Constants:
                 addUserDirs(dataDirs);
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p / "constants").string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "constants"; });
                 break;
             case ImHexPath::Encodings:
                 addUserDirs(dataDirs);
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p / "encodings").string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "encodings"; });
                 break;
             case ImHexPath::Logs:
-                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return (p / "logs").string(); });
+                std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "logs"; });
                 break;
             default:
                 hex::unreachable();

lib/libimhex/source/helpers/net.cpp

@@ -122,7 +122,7 @@ namespace hex {
     std::optional<i32> Net::execute() {
         CURLcode result = curl_easy_perform(this->m_ctx);
         if (result != CURLE_OK)
-            log::error("Net request failed with error {0}: '{1}'", result, curl_easy_strerror(result));
+            log::error("Net request failed with error {0}: '{1}'", u32(result), curl_easy_strerror(result));
 
         i32 responseCode = 0;
         curl_easy_getinfo(this->m_ctx, CURLINFO_RESPONSE_CODE, &responseCode);
@@ -180,7 +180,7 @@ namespace hex {
 
             ON_SCOPE_EXIT { this->m_transmissionActive.unlock(); };
 
-            fs::File file(filePath.string(), fs::File::Mode::Read);
+            fs::File file(filePath, fs::File::Mode::Read);
             if (!file.isValid())
                 return Response<std::string> { 400, {} };
 
@@ -218,7 +218,7 @@ namespace hex {
 
             ON_SCOPE_EXIT { this->m_transmissionActive.unlock(); };
 
-            fs::File file(filePath.string(), fs::File::Mode::Create);
+            fs::File file(filePath, fs::File::Mode::Create);
             if (!file.isValid())
                 return Response<void> { 400 };
 
@@ -245,6 +245,19 @@ namespace hex {
         return {};
     }
 
+    std::string Net::decode(const std::string &input) {
+        auto unescapedString = curl_easy_unescape(this->m_ctx, input.c_str(), std::strlen(input.c_str()), nullptr);
+
+        if (unescapedString != nullptr) {
+            std::string output = unescapedString;
+            curl_free(unescapedString);
+
+            return output;
+        }
+
+        return {};
+    }
+
     std::string Net::s_proxyUrl;
 
     void Net::setProxy(const std::string &url) {

lib/libimhex/source/helpers/project_file_handler.cpp

@@ -52,10 +52,10 @@ namespace hex {
         json projectFileData;
 
         try {
-            std::ifstream projectFile(filePath.c_str());
+            std::ifstream projectFile(filePath);
             projectFile >> projectFileData;
 
-            ProjectFile::s_filePath             = std::fs::path(projectFileData["filePath"].get<std::string>());
+            ProjectFile::s_filePath             = std::fs::path(projectFileData["filePath"].get<std::u8string>());
             ProjectFile::s_pattern              = projectFileData["pattern"];
             ProjectFile::s_patches              = projectFileData["patches"].get<Patches>();
             ProjectFile::s_dataProcessorContent = projectFileData["dataProcessor"];
@@ -89,7 +89,7 @@ namespace hex {
             filePath = ProjectFile::s_currProjectFilePath;
 
         try {
-            projectFileData["filePath"]      = ProjectFile::s_filePath.string();
+            projectFileData["filePath"]      = ProjectFile::s_filePath.u8string();
             projectFileData["pattern"]       = ProjectFile::s_pattern;
             projectFileData["patches"]       = ProjectFile::s_patches;
             projectFileData["dataProcessor"] = ProjectFile::s_dataProcessorContent;

lib/libimhex/source/ui/imgui_imhex_extensions.cpp

@@ -334,8 +334,8 @@ namespace ImGui {
         glGenTextures(1, &texture);
         glBindTexture(GL_TEXTURE_2D, texture);
 
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
 #if defined(GL_UNPACK_ROW_LENGTH)
         glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
@@ -553,6 +553,10 @@ namespace ImGui {
         return ImGui::InputText(label, buffer.data(), buffer.size() + 1, ImGuiInputTextFlags_CallbackResize | flags, ImGui::UpdateStringSizeCallback, &buffer);
     }
 
+    bool InputText(const char *label, std::u8string &buffer, ImGuiInputTextFlags flags) {
+        return ImGui::InputText(label, reinterpret_cast<char *>(buffer.data()), buffer.size() + 1, ImGuiInputTextFlags_CallbackResize | flags, ImGui::UpdateStringSizeCallback, &buffer);
+    }
+
     bool InputTextMultiline(const char *label, std::string &buffer, const ImVec2 &size, ImGuiInputTextFlags flags) {
         return ImGui::InputTextMultiline(label, buffer.data(), buffer.size() + 1, size, ImGuiInputTextFlags_CallbackResize | flags, ImGui::UpdateStringSizeCallback, &buffer);
     }

main/CMakeLists.txt

@@ -26,7 +26,7 @@ set_target_properties(main PROPERTIES
 add_compile_definitions(IMHEX_PROJECT_NAME="${PROJECT_NAME}")
 
 if (WIN32)
-    target_link_libraries(main PUBLIC libimhex wsock32 ws2_32 Dwmapi.lib)
+    target_link_libraries(main PUBLIC usp10 libimhex wsock32 ws2_32 Dwmapi.lib)
 else ()
     target_link_libraries(main PUBLIC libimhex pthread)
 endif ()

main/source/window/window.cpp

@@ -118,7 +118,7 @@ namespace hex {
                 return;
 
             for (const auto &path : fs::getDefaultPaths(fs::ImHexPath::Config)) {
-                if (ProjectFile::store((std::fs::path(path) / CrashBackupFileName).string()))
+                if (ProjectFile::store(std::fs::path(path) / CrashBackupFileName))
                     break;
             }
         });
@@ -198,7 +198,7 @@ namespace hex {
 
         ImGuiViewport *viewport = ImGui::GetMainViewport();
         ImGui::SetNextWindowPos(viewport->WorkPos);
-        ImGui::SetNextWindowSize(viewport->WorkSize);
+        ImGui::SetNextWindowSize(ImHexApi::System::getMainWindowSize() - ImVec2(0, ImGui::GetTextLineHeightWithSpacing()));
         ImGui::SetNextWindowViewport(viewport->ID);
         ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
         ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
@@ -558,7 +558,8 @@ namespace hex {
         });
 
         glfwSetWindowSizeCallback(this->m_window, [](GLFWwindow *window, int width, int height) {
-            ImHexApi::System::impl::setMainWindowSize(width, height);
+            if (!glfwGetWindowAttrib(window, GLFW_ICONIFIED))
+                ImHexApi::System::impl::setMainWindowSize(width, height);
 
             if (auto g = ImGui::GetCurrentContext(); g == nullptr || g->WithinFrameScope) return;
 

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

@@ -21,7 +21,7 @@ namespace hex::plugin::builtin {
         void drawContent() override;
 
     private:
-        std::map<prv::Provider *, std::vector<std::shared_ptr<pl::Pattern>>> m_sortedPatterns;
+        std::map<prv::Provider *, std::vector<pl::Pattern*>> m_sortedPatterns;
         hex::PatternDrawer m_patternDrawer;
     };
 

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

@@ -56,7 +56,6 @@ namespace hex::plugin::builtin {
         };
 
         std::map<std::string, PatternVariable> m_patternVariables;
-        std::vector<std::string> m_patternTypes;
 
         enum class EnvVarType
         {
@@ -102,4 +101,4 @@ namespace hex::plugin::builtin {
         void evaluatePattern(const std::string &code);
     };
 
-}
+}

plugins/builtin/source/content/data_inspector.cpp

@@ -54,7 +54,7 @@ namespace hex::plugin::builtin {
 
     template<std::floating_point T>
     static std::vector<u8> stringToFloat(const std::string &value, std::endian endian) requires(sizeof(T) <= sizeof(long double)) {
-        auto result = std::strtold(value.c_str(), nullptr);
+        T result = std::strtold(value.c_str(), nullptr);
 
         std::vector<u8> bytes(sizeof(T), 0x00);
         std::memcpy(bytes.data(), &result, bytes.size());
@@ -349,7 +349,7 @@ namespace hex::plugin::builtin {
 
         ContentRegistry::DataInspector::add("hex.builtin.inspector.string", 1,
             [](auto buffer, auto endian, auto style) {
-                hex::unused(endian, style);
+                hex::unused(buffer, endian, style);
 
                 auto currSelection = ImHexApi::HexEditor::getSelection();
 
@@ -358,14 +358,15 @@ namespace hex::plugin::builtin {
                 std::string value, copyValue;
 
                 if (currSelection.has_value()) {
-                    std::vector<u8> stringBuffer(std::min<size_t>(MaxStringLength, currSelection->size), 0x00);
+                    std::vector<u8> stringBuffer(std::min<size_t>(currSelection->size, 0x1000), 0x00);
                     ImHexApi::Provider::get()->read(currSelection->address, stringBuffer.data(), stringBuffer.size());
 
-                    value = hex::encodeByteString(stringBuffer);
-                    copyValue = hex::encodeByteString(buffer);
+                    value = copyValue = hex::encodeByteString(stringBuffer);
 
-                    if (currSelection->size > MaxStringLength)
+                    if (currSelection->size > MaxStringLength) {
+                        value.resize(MaxStringLength);
                         value += "...";
+                    }
                 } else {
                     value = "";
                     copyValue = "";

plugins/builtin/source/content/data_processor_nodes.cpp

@@ -91,7 +91,7 @@ namespace hex::plugin::builtin {
         }
 
         void load(nlohmann::json &j) override {
-            this->m_value = j["data"];
+            this->m_value = j["data"].get<std::string>();
         }
 
     private:
@@ -213,7 +213,7 @@ namespace hex::plugin::builtin {
         }
 
         void load(nlohmann::json &j) override {
-            this->m_comment = j["comment"];
+            this->m_comment = j["comment"].get<std::string>();
         }
 
     private:

plugins/builtin/source/content/settings_entries.cpp

@@ -13,6 +13,19 @@
 
 #include <nlohmann/json.hpp>
 
+namespace {
+    static std::vector<std::fs::path> userFolders;
+    static void loadUserFoldersFromSetting(nlohmann::json &setting) {
+        userFolders.clear();
+        std::vector<std::string> paths = setting;
+        for (const auto &path : paths) {
+            // JSON reads char8_t as array, char8_t is not supported as of now
+            std::u8string_view uString(reinterpret_cast<const char8_t *>(&path.front()), reinterpret_cast<const char8_t *>(std::next(&path.back())));
+            userFolders.emplace_back(uString);
+        }
+    }
+};
+
 namespace hex::plugin::builtin {
 
     void registerSettings() {
@@ -247,7 +260,7 @@ namespace hex::plugin::builtin {
                 for (const auto &[unlocalizedName, visualizer] : visualizers) {
                     if (ImGui::Selectable(LangEntry(unlocalizedName))) {
                         setting = unlocalizedName;
-                        result = true;
+                        result  = true;
                     }
                 }
 
@@ -314,34 +327,27 @@ namespace hex::plugin::builtin {
         ContentRegistry::Settings::add(dirsSetting, dirsSetting, std::vector<std::string> {}, [](auto name, nlohmann::json &setting) {
             hex::unused(name);
 
-            static size_t currentItemIndex = 0;
-            static std::vector<std::fs::path> folders = [&setting]{
-                std::vector<std::fs::path> result;
+            static size_t currentItemIndex = [&setting] {loadUserFoldersFromSetting(setting); return 0; }();
 
-                std::vector<std::u8string> paths = setting;
-                for (const auto &path : paths)
-                    result.emplace_back(path);
-
-                return result;
-            }();
+            auto saveToSetting = [&setting] {
+                std::vector<std::string> folderStrings;
+                for (const auto &folder : userFolders) {
+                    auto utfString = folder.u8string();
+                    // JSON stores char8_t as array, char8_t is not supported as of now
+                    folderStrings.emplace_back(reinterpret_cast<const char *>(&utfString.front()), reinterpret_cast<const char *>(std::next(&utfString.back())));
+                }
+                setting = folderStrings;
+                ImHexApi::System::setAdditionalFolderPaths(userFolders);
+            };
 
             bool result = false;
 
-            auto writeSetting = [&setting]{
-                std::vector<std::u8string> folderStrings;
-                for (const auto &folder : folders)
-                    folderStrings.push_back(folder.u8string());
-                setting = folderStrings;
-
-                ImHexApi::System::setAdditionalFolderPaths(folders);
-            };
-
             if (!ImGui::BeginListBox("", ImVec2(-38, -FLT_MIN))) {
                 return false;
             } else {
-                for (size_t n = 0; n < folders.size(); n++) {
+                for (size_t n = 0; n < userFolders.size(); n++) {
                     const bool isSelected = (currentItemIndex == n);
-                    if (ImGui::Selectable(folders.at(n).string().c_str(), isSelected)) { currentItemIndex = n; }
+                    if (ImGui::Selectable(userFolders.at(n).string().c_str(), isSelected)) { currentItemIndex = n; }
                     if (isSelected) { ImGui::SetItemDefaultFocus(); }
                 }
                 ImGui::EndListBox();
@@ -351,12 +357,9 @@ namespace hex::plugin::builtin {
 
             if (ImGui::IconButton(ICON_VS_NEW_FOLDER, ImGui::GetCustomColorVec4(ImGuiCustomCol_DescButton), ImVec2(30, 30))) {
                 fs::openFileBrowser(fs::DialogMode::Folder, {}, [&](const std::fs::path &path) {
-
-                    if (std::find(folders.begin(), folders.end(), path) == folders.end()) {
-                        folders.emplace_back(path);
-
-                        writeSetting();
-
+                    if (std::find(userFolders.begin(), userFolders.end(), path) == userFolders.end()) {
+                        userFolders.emplace_back(path);
+                        saveToSetting();
                         result = true;
                     }
                 });
@@ -364,10 +367,9 @@ namespace hex::plugin::builtin {
             ImGui::InfoTooltip("hex.builtin.setting.folders.add_folder"_lang);
 
             if (ImGui::IconButton(ICON_VS_REMOVE_CLOSE, ImGui::GetCustomColorVec4(ImGuiCustomCol_DescButton), ImVec2(30, 30))) {
-                if (!folders.empty()) {
-                    folders.erase(std::next(folders.begin(), currentItemIndex));
-
-                    writeSetting();
+                if (!userFolders.empty()) {
+                    userFolders.erase(std::next(userFolders.begin(), currentItemIndex));
+                    saveToSetting();
 
                     result = true;
                 }
@@ -480,10 +482,18 @@ namespace hex::plugin::builtin {
         ImHexApi::System::setTheme(static_cast<ImHexApi::System::Theme>(theme));
     }
 
+    static void loadFoldersSettings() {
+        static const std::string dirsSetting { "hex.builtin.setting.folders" };
+        auto dirs = ContentRegistry::Settings::getSetting(dirsSetting, dirsSetting);
+        loadUserFoldersFromSetting(dirs);
+        ImHexApi::System::setAdditionalFolderPaths(userFolders);
+    }
+
     void loadSettings() {
         loadInterfaceScalingSetting();
         loadFontSettings();
         loadThemeSettings();
+        loadFoldersSettings();
     }
 
 }

plugins/builtin/source/content/tools_entries.cpp

@@ -712,8 +712,8 @@ namespace hex::plugin::builtin {
 
                     auto json = nlohmann::json::parse(response.body);
 
-                    resultTitle   = json["query"]["pages"][0]["title"];
-                    resultExtract = json["query"]["pages"][0]["extract"];
+                    resultTitle   = json["query"]["pages"][0]["title"].get<std::string>();
+                    resultExtract = json["query"]["pages"][0]["extract"].get<std::string>();
 
                     if (!extendedSearch && resultExtract.ends_with(':')) {
                         extendedSearch = true;
@@ -739,7 +739,7 @@ namespace hex::plugin::builtin {
 
         void drawFileToolShredder() {
             static bool shredding    = false;
-            static auto selectedFile = [] { std::string s; s.reserve(0x1000); return s; }();
+            static std::u8string selectedFile;
             static bool fastMode     = false;
 
             ImGui::TextUnformatted("hex.builtin.tools.file_tools.shredder.warning"_lang);
@@ -754,7 +754,7 @@ namespace hex::plugin::builtin {
                     ImGui::SameLine();
                     if (ImGui::Button("...")) {
                         fs::openFileBrowser(fs::DialogMode::Open, {}, [](const auto &path) {
-                            selectedFile = path.string();
+                            selectedFile = path.u8string();
                         });
                     }
 
@@ -883,11 +883,11 @@ namespace hex::plugin::builtin {
                 1
             };
 
-            static bool splitting      = false;
-            static auto selectedFile   = [] { std::string s; s.reserve(0x1000); return s; }();
-            static auto baseOutputPath = [] { std::string s; s.reserve(0x1000); return s; }();
-            static u64 splitSize       = sizes[0];
-            static int selectedItem    = 0;
+            static bool splitting = false;
+            static std::u8string selectedFile;
+            static std::u8string baseOutputPath;
+            static u64 splitSize = sizes[0];
+            static int selectedItem = 0;
 
             if (ImGui::BeginChild("split_settings", { 0, ImGui::GetTextLineHeightWithSpacing() * 7 }, true, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse)) {
                 ImGui::BeginDisabled(splitting);
@@ -896,7 +896,7 @@ namespace hex::plugin::builtin {
                     ImGui::SameLine();
                     if (ImGui::Button("...##input")) {
                         fs::openFileBrowser(fs::DialogMode::Open, {}, [](const auto &path) {
-                            selectedFile = path.string();
+                            selectedFile = path.u8string();
                         });
                     }
                     ImGui::SameLine();
@@ -906,7 +906,7 @@ namespace hex::plugin::builtin {
                     ImGui::SameLine();
                     if (ImGui::Button("...##output")) {
                         fs::openFileBrowser(fs::DialogMode::Save, {}, [](const auto &path) {
-                            baseOutputPath = path.string();
+                            baseOutputPath = path.u8string();
                         });
                     }
                     ImGui::SameLine();
@@ -960,7 +960,10 @@ namespace hex::plugin::builtin {
                             for (u64 offset = 0; offset < file.getSize(); offset += splitSize) {
                                 task.update(offset);
 
-                                fs::File partFile(baseOutputPath + hex::format(".{:05}", index), fs::File::Mode::Create);
+                                std::fs::path path = baseOutputPath;
+                                path += hex::format(".{:05}", index);
+
+                                fs::File partFile(path, fs::File::Mode::Create);
 
                                 if (!partFile.isValid()) {
                                     View::showErrorPopup(hex::format("hex.builtin.tools.file_tools.splitter.error.create"_lang, index));
@@ -986,8 +989,8 @@ namespace hex::plugin::builtin {
 
         void drawFileToolCombiner() {
             static bool combining = false;
-            static std::vector<std::string> files;
-            static auto outputPath = [] { std::string s; s.reserve(0x1000); return s; }();
+            static std::vector<std::fs::path> files;
+            static std::u8string outputPath;
             static u32 selectedIndex;
 
             if (ImGui::BeginTable("files_table", 2, ImGuiTableFlags_SizingStretchProp)) {
@@ -1035,7 +1038,7 @@ namespace hex::plugin::builtin {
                 {
                     if (ImGui::Button("hex.builtin.tools.file_tools.combiner.add"_lang)) {
                         fs::openFileBrowser(fs::DialogMode::Open, {}, [](const auto &path) {
-                            files.push_back(path.string());
+                            files.push_back(path);
                         });
                     }
                     ImGui::SameLine();
@@ -1059,7 +1062,7 @@ namespace hex::plugin::builtin {
                 ImGui::SameLine();
                 if (ImGui::Button("...")) {
                     fs::openFileBrowser(fs::DialogMode::Save, {}, [](const auto &path) {
-                        outputPath = path.string();
+                        outputPath = path.u8string();
                     });
                 }
                 ImGui::SameLine();

plugins/builtin/source/content/ui_items.cpp

@@ -107,8 +107,11 @@ namespace hex::plugin::builtin {
 
                 u32 index = 0;
                 for (auto &path : s_selectableFiles) {
+                    ImGui::PushID(index);
                     if (ImGui::Selectable(path.filename().string().c_str(), index == s_selectableFileIndex))
                         s_selectableFileIndex = index;
+                    ImGui::PopID();
+
                     index++;
                 }
 

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

@@ -34,11 +34,11 @@ namespace hex::plugin::builtin {
 
                     for (auto value : content["values"]) {
                         Constant constant;
-                        constant.category = content["name"];
-                        constant.name     = value["name"];
+                        constant.category = content["name"].get<std::string>();
+                        constant.name     = value["name"].get<std::string>();
                         if (value.contains("desc"))
-                            constant.description = value["desc"];
-                        constant.value = value["value"];
+                            constant.description = value["desc"].get<std::string>();
+                        constant.value = value["value"].get<std::string>();
 
                         auto type = value["type"];
                         if (type == "int10")

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

@@ -104,8 +104,10 @@ namespace hex::plugin::builtin {
             if (ImGui::BeginTabBar("##find_tabs")) {
                 if (ImGui::BeginTabItem("hex.builtin.view.hex_editor.search.hex"_lang)) {
                     if (ImGui::InputText("##input", this->m_input, ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_CharsHexadecimal)) {
-                        this->m_shouldSearch = true;
-                        this->m_backwards = false;
+                        if (!this->m_input.empty()) {
+                            this->m_shouldSearch = true;
+                            this->m_backwards = false;
+                        }
                     }
 
                     this->drawButtons();
@@ -119,8 +121,10 @@ namespace hex::plugin::builtin {
 
                 if (ImGui::BeginTabItem("hex.builtin.view.hex_editor.search.string"_lang)) {
                     if (ImGui::InputText("##input", this->m_input, ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll)) {
-                        this->m_shouldSearch = true;
-                        this->m_backwards = false;
+                       if (!this->m_input.empty()) {
+                            this->m_shouldSearch = true;
+                            this->m_backwards = false;
+                       }
                     }
 
                     this->drawButtons();
@@ -434,15 +438,15 @@ namespace hex::plugin::builtin {
         const auto [decoded, advance] = encodingFile.getEncodingFor(buffer);
         const ImColor color = [&decoded = decoded, &advance = advance]{
             if (decoded.length() == 1 && std::isalnum(decoded[0]))
-                return 0xFFFF8000;
+                return ImGui::GetCustomColorU32(ImGuiCustomCol_ToolbarBlue);
             else if (decoded.length() == 1 && advance == 1)
-                return 0xFF0000FF;
+                return ImGui::GetCustomColorU32(ImGuiCustomCol_ToolbarRed);
             else if (decoded.length() > 1 && advance == 1)
-                return 0xFF00FFFF;
+                return ImGui::GetCustomColorU32(ImGuiCustomCol_ToolbarYellow);
             else if (advance > 1)
-                return 0xFFFFFFFF;
+                return ImGui::GetColorU32(ImGuiCol_Text);
             else
-                return 0xFFFF8000;
+                return ImGui::GetCustomColorU32(ImGuiCustomCol_ToolbarBlue);
         }();
 
         return { std::string(decoded), advance, color };
@@ -830,16 +834,18 @@ namespace hex::plugin::builtin {
                             } while (offset < this->m_bytesPerRow);
 
                             ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, ImVec2(0, 0));
-                            if (ImGui::BeginTable("##encoding_cell", encodingData.size(), ImGuiTableFlags_SizingFixedFit)) {
+                            ImGui::PushID(y);
+                            if (ImGui::BeginTable("##encoding_cell", encodingData.size(), ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_NoKeepColumnsVisible)) {
                                 ImGui::TableNextRow();
 
                                 for (const auto &[address, data] : encodingData) {
                                     ImGui::TableNextColumn();
 
                                     const auto cellStartPos = getCellPosition();
-                                    const auto cellSize = CharacterSize * data.advance;
+                                    const auto cellSize = CharacterSize * ImVec2(std::max<float>(1, data.displayValue.length()), 1);
                                     const bool cellHovered = ImGui::IsMouseHoveringRect(cellStartPos, cellStartPos + cellSize, true);
 
+
                                     const auto x = address % this->m_bytesPerRow;
                                     if (x < validBytes) {
                                         auto [foregroundColor, backgroundColor] = cellColors[x];
@@ -854,7 +860,9 @@ namespace hex::plugin::builtin {
                                             this->drawSelectionFrame(x, y, address, 1, cellStartPos, cellSize);
                                         }
 
+                                        ImGui::PushItemWidth(cellSize.x);
                                         ImGui::TextFormattedColored(data.color, "{}", data.displayValue);
+                                        ImGui::PopItemWidth();
 
                                         this->handleSelection(address, data.advance, &bytes[address % this->m_bytesPerRow], cellHovered);
                                     }
@@ -863,6 +871,7 @@ namespace hex::plugin::builtin {
                                 ImGui::EndTable();
                             }
                             ImGui::PopStyleVar();
+                            ImGui::PopID();
 
                         }
 
@@ -1222,7 +1231,7 @@ namespace hex::plugin::builtin {
         });
 
         // Open file
-        ShortcutManager::addShortcut(this, CTRL + Keys::O, [] {
+        ShortcutManager::addGlobalShortcut(CTRL + Keys::O, [] {
             fs::openFileBrowser(fs::DialogMode::Open, {}, [](const auto &path) {
                 EventManager::post<RequestOpenFile>(path);
             });

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

@@ -67,7 +67,7 @@ namespace hex::plugin::builtin {
         return false;
     }
 
-    static bool beginPatternTable(prv::Provider *&provider, const std::vector<std::shared_ptr<pl::Pattern>> &patterns, std::vector<std::shared_ptr<pl::Pattern>> &sortedPatterns) {
+    static bool beginPatternTable(prv::Provider *&provider, const std::vector<std::shared_ptr<pl::Pattern>> &patterns, std::vector<pl::Pattern*> &sortedPatterns) {
         if (ImGui::BeginTable("##Patterntable", 6, ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Sortable | ImGuiTableFlags_Hideable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
             ImGui::TableSetupScrollFreeze(0, 1);
             ImGui::TableSetupColumn("hex.builtin.view.pattern_data.var_name"_lang, 0, 0, ImGui::GetID("name"));
@@ -80,10 +80,12 @@ namespace hex::plugin::builtin {
             auto sortSpecs = ImGui::TableGetSortSpecs();
 
             if (sortSpecs->SpecsDirty || sortedPatterns.empty()) {
-                sortedPatterns = patterns;
+                std::transform(patterns.begin(), patterns.end(), std::back_inserter(sortedPatterns), [](const std::shared_ptr<pl::Pattern> &pattern) {
+                    return pattern.get();
+                });
 
-                std::sort(sortedPatterns.begin(), sortedPatterns.end(), [&sortSpecs, &provider](const std::shared_ptr<pl::Pattern> &left, const std::shared_ptr<pl::Pattern> &right) -> bool {
-                    return sortPatterns(provider, sortSpecs, left.get(), right.get());
+                std::sort(sortedPatterns.begin(), sortedPatterns.end(), [&sortSpecs, &provider](pl::Pattern *left, pl::Pattern *right) -> bool {
+                    return sortPatterns(provider, sortSpecs, left, right);
                 });
 
                 for (auto &pattern : sortedPatterns)

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

@@ -28,7 +28,7 @@ namespace hex::plugin::builtin {
                 langDef.mKeywords.insert(k);
 
             static constexpr std::array builtInTypes = {
-                "u8", "u16", "u32", "u64", "u128", "s8", "s16", "s32", "s64", "s128", "float", "double", "char", "char16", "bool", "padding", "str", "auto"
+                "u8", "u16", "u24", "u32", "u48", "u64", "u96", "u128", "s8", "s16", "s24", "s32", "s48", "s64", "s96", "s128", "float", "double", "char", "char16", "bool", "padding", "str", "auto"
             };
             for (const auto name : builtInTypes) {
                 TextEditor::Identifier id;
@@ -93,9 +93,7 @@ namespace hex::plugin::builtin {
         });
 
         EventManager::subscribe<RequestSetPatternLanguageCode>(this, [this](const std::string &code) {
-            this->m_textEditor.SelectAll();
-            this->m_textEditor.Delete();
-            this->m_textEditor.InsertText(code);
+            this->m_textEditor.SetText(code);
         });
 
         EventManager::subscribe<EventFileLoaded>(this, [this](const std::fs::path &path) {
@@ -127,7 +125,7 @@ namespace hex::plugin::builtin {
 
             std::error_code errorCode;
             for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Patterns)) {
-                for (auto &entry : std::fs::directory_iterator(dir, errorCode)) {
+                for (auto &entry : std::fs::recursive_directory_iterator(dir, errorCode)) {
                     foundCorrectType = false;
                     if (!entry.is_regular_file())
                         continue;
@@ -185,7 +183,7 @@ namespace hex::plugin::builtin {
         }
 
         ContentRegistry::FileHandler::add({ ".hexpat", ".pat" }, [](const std::fs::path &path) -> bool {
-            fs::File file(path.string(), fs::File::Mode::Read);
+            fs::File file(path, fs::File::Mode::Read);
 
             if (file.isValid()) {
                 EventManager::post<RequestSetPatternLanguageCode>(file.readString());
@@ -236,31 +234,42 @@ namespace hex::plugin::builtin {
             if (this->m_runningEvaluators != 0)
                 return std::nullopt;
 
-            const auto pattern = ImHexApi::Provider::get()->getPatternLanguageRuntime().getPattern(address);
-            if (pattern != nullptr)
-                return pattern->getColor();
-            else
+            bool foundColor = false;
+            ImColor color = ImColor(0xFF, 0xFF, 0xFF, 0x70);
+            for (const auto &pattern : ImHexApi::Provider::get()->getPatternLanguageRuntime().getPatterns(address)) {
+                color = ImAlphaBlendColors(color, pattern->getColor());
+
+                foundColor = true;
+            }
+
+            if (!foundColor)
                 return std::nullopt;
+            else {
+                color.Value.w = 0x70;
+                return color;
+            }
         });
 
         ImHexApi::HexEditor::addTooltipProvider([this](u64 address, const u8 *data, size_t size) {
             hex::unused(data, size);
 
-            auto pattern = ImHexApi::Provider::get()->getPatternLanguageRuntime().getPattern(address);
-            if (pattern != nullptr) {
+            auto patterns = ImHexApi::Provider::get()->getPatternLanguageRuntime().getPatterns(address);
+            if (!patterns.empty()) {
                 ImGui::BeginTooltip();
-
                 if (ImGui::BeginTable("##tooltips", 1, ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_RowBg | ImGuiTableFlags_NoClip)) {
-                    ImGui::TableNextRow();
-                    ImGui::TableNextColumn();
+                    for (const auto &pattern : patterns) {
+                        auto tooltipColor = (pattern->getColor() & 0x00FF'FFFF) | 0x7000'0000;
+                        ImGui::PushStyleColor(ImGuiCol_TableRowBg, tooltipColor);
+                        ImGui::PushStyleColor(ImGuiCol_TableRowBgAlt, tooltipColor);
 
-                    this->drawPatternTooltip(pattern);
+                        ImGui::TableNextRow();
+                        ImGui::TableNextColumn();
 
-                    auto tooltipColor = (pattern->getColor() & 0x00FF'FFFF) | 0x7000'0000;
-                    ImGui::PushStyleColor(ImGuiCol_TableRowBg, tooltipColor);
-                    ImGui::PushStyleColor(ImGuiCol_TableRowBgAlt, tooltipColor);
+                        ImGui::PopStyleColor(2);
+
+                        this->drawPatternTooltip(pattern);
+                    }
                     ImGui::EndTable();
-                    ImGui::PopStyleColor(2);
                 }
                 ImGui::EndTooltip();
             }
@@ -558,25 +567,27 @@ namespace hex::plugin::builtin {
                         if (variable.outVariable) {
                             ImGui::TextUnformatted(pl::Token::literalToString(variable.value, true).c_str());
                         } else if (variable.inVariable) {
+                            const std::string label { "##" + name };
+
                             if (pl::Token::isSigned(variable.type)) {
                                 i64 value = hex::get_or<i128>(variable.value, 0);
-                                ImGui::InputScalar("", ImGuiDataType_S64, &value);
+                                ImGui::InputScalar(label.c_str(), ImGuiDataType_S64, &value);
                                 variable.value = i128(value);
                             } else if (pl::Token::isUnsigned(variable.type)) {
                                 u64 value = hex::get_or<u128>(variable.value, 0);
-                                ImGui::InputScalar("", ImGuiDataType_U64, &value);
+                                ImGui::InputScalar(label.c_str(), ImGuiDataType_U64, &value);
                                 variable.value = u128(value);
                             } else if (pl::Token::isFloatingPoint(variable.type)) {
                                 double value = hex::get_or<double>(variable.value, 0.0);
-                                ImGui::InputScalar("", ImGuiDataType_Double, &value);
+                                ImGui::InputScalar(label.c_str(), ImGuiDataType_Double, &value);
                                 variable.value = value;
                             } else if (variable.type == pl::Token::ValueType::Boolean) {
                                 bool value = hex::get_or<bool>(variable.value, false);
-                                ImGui::Checkbox("", &value);
+                                ImGui::Checkbox(label.c_str(), &value);
                                 variable.value = value;
                             } else if (variable.type == pl::Token::ValueType::Character) {
                                 char buffer[2];
-                                ImGui::InputText("", buffer, 2);
+                                ImGui::InputText(label.c_str(), buffer, 2);
                                 variable.value = buffer[0];
                             }
                         }
@@ -619,7 +630,7 @@ namespace hex::plugin::builtin {
 
             confirmButtons(
                 "hex.builtin.common.yes"_lang, "hex.builtin.common.no"_lang, [this] {
-                this->loadPatternFile(this->m_possiblePatternFiles[this->m_selectedPatternFile].string());
+                this->loadPatternFile(this->m_possiblePatternFiles[this->m_selectedPatternFile]);
                 ImGui::CloseCurrentPopup(); }, [] { ImGui::CloseCurrentPopup(); });
 
             if (ImGui::IsKeyDown(ImGui::GetKeyIndex(ImGuiKey_Escape)))
@@ -717,7 +728,6 @@ namespace hex::plugin::builtin {
             auto ast = this->m_parserRuntime->parseString(code);
 
             this->m_patternVariables.clear();
-            this->m_patternTypes.clear();
 
             if (ast) {
                 for (auto &node : *ast) {
@@ -752,7 +762,7 @@ namespace hex::plugin::builtin {
 
         this->m_textEditor.SetErrorMarkers({});
         this->m_console.clear();
-        this->clearPatterns();
+        ImHexApi::Provider::get()->getPatternLanguageRuntime().reset();
 
         EventManager::post<EventHighlightingChanged>();
 

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

@@ -191,7 +191,7 @@ namespace hex::plugin::builtin {
                 [](const char *includeName, const char *, const char *, void *userData) -> const char * {
                     auto currFilePath = static_cast<const char *>(userData);
 
-                    fs::File file((std::fs::path(currFilePath).parent_path() / includeName).string(), fs::File::Mode::Read);
+                    fs::File file(std::fs::path(currFilePath).parent_path() / includeName, fs::File::Mode::Read);
                     if (!file.isValid())
                         return nullptr;
 

plugins/builtin/source/content/welcome_screen.cpp

@@ -25,19 +25,16 @@
 
 namespace hex::plugin::builtin {
 
-    static bool s_layoutConfigured = false;
-    static ImGui::Texture s_bannerTexture;
-    static std::string s_bannerTextureName;
+    static ImGui::Texture s_bannerTexture, s_backdropTexture;
     static std::list<std::fs::path> s_recentFilePaths;
 
     static std::fs::path s_safetyBackupPath;
 
     static std::string s_tipOfTheDay;
 
-    static void initDefaultLayout() {
+    static void loadDefaultLayout() {
         auto layouts = ContentRegistry::Interface::getLayouts();
         if (!layouts.empty()) {
-            s_layoutConfigured = true;
 
             for (auto &[viewName, view] : ContentRegistry::Views::getEntries()) {
                 view->getWindowOpenState() = false;
@@ -52,6 +49,14 @@ namespace hex::plugin::builtin {
         }
     }
 
+    static bool isAnyViewOpen() {
+        const auto &views = ContentRegistry::Views::getEntries();
+        return std::any_of(views.begin(), views.end(),
+            [](const std::pair<std::string, View*> &entry) {
+                return entry.second->getWindowOpenState();
+            });
+    }
+
     static void drawPopups() {
         ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_Appearing, ImVec2(0.5F, 0.5F));
         ImGui::SetNextWindowSize(ImGui::GetMainViewport()->Size / 3, ImGuiCond_Appearing);
@@ -84,7 +89,7 @@ namespace hex::plugin::builtin {
             auto width = ImGui::GetWindowWidth();
             ImGui::SetCursorPosX(width / 9);
             if (ImGui::Button("hex.builtin.welcome.safety_backup.restore"_lang, ImVec2(width / 3, 0))) {
-                ProjectFile::load(s_safetyBackupPath.string());
+                ProjectFile::load(s_safetyBackupPath);
                 ProjectFile::markDirty();
 
                 ProjectFile::clearProjectFilePath();
@@ -282,8 +287,32 @@ namespace hex::plugin::builtin {
         drawPopups();
     }
 
+    static void drawNoViewsBackground() {
+        if (isAnyViewOpen() && ImHexApi::Provider::isValid()) return;
+
+        if (ImGui::Begin("ImHexDockSpace")) {
+            static char title[256];
+            ImFormatString(title, IM_ARRAYSIZE(title), "%s/DockSpace_%08X", ImGui::GetCurrentWindow()->Name, ImGui::GetID("ImHexMainDock"));
+            if (ImGui::Begin(title)) {
+                ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(10_scaled, 10_scaled));
+                if (ImGui::BeginChild("NoViewsBackground", ImVec2(0, 0), false, ImGuiWindowFlags_AlwaysUseWindowPadding | ImGuiWindowFlags_NoScrollWithMouse)) {
+                    auto imageSize = scaled(ImVec2(350, 350));
+                    auto pos = (ImGui::GetContentRegionAvail() - imageSize) / 2;
+
+                    ImGui::SetCursorPos(pos);
+                    ImGui::Image(s_backdropTexture, imageSize);
+                }
+                ImGui::EndChild();
+                ImGui::PopStyleVar();
+            }
+            ImGui::End();
+        }
+        ImGui::End();
+    }
+
     void createWelcomeScreen() {
         (void)EventManager::subscribe<EventFrameBegin>(drawWelcomeScreen);
+        (void)EventManager::subscribe<EventFrameBegin>(drawNoViewsBackground);
 
         (void)EventManager::subscribe<EventSettingsChanged>([]() {
             {
@@ -316,27 +345,17 @@ namespace hex::plugin::builtin {
                 if (targetFps.is_number())
                     ImHexApi::System::setTargetFPS(targetFps);
             }
-
-            {
-                if (ContentRegistry::Settings::read("hex.builtin.setting.imhex", "hex.builtin.setting.imhex.launched", 0) == 1)
-                    s_layoutConfigured = true;
-                else
-                    ContentRegistry::Settings::write("hex.builtin.setting.imhex", "hex.builtin.setting.imhex.launched", 1);
-            }
         });
 
         (void)EventManager::subscribe<RequestChangeTheme>([](u32 theme) {
-            auto changeBannerTexture = [&](const char newTexture[]) {
-                if (s_bannerTextureName == newTexture) {
-                    return;
-                }
+            auto changeTexture = [&](const std::string &path, const ImGui::Texture &texture) {
+                auto textureData = romfs::get(path);
+                auto oldTexture  = texture;
+                auto newTexture  = ImGui::LoadImageFromMemory(reinterpret_cast<const ImU8 *>(textureData.data()), textureData.size());
 
-                s_bannerTextureName   = newTexture;
-                auto banner           = romfs::get(newTexture);
-                auto oldBannerTexture = s_bannerTexture;
-                s_bannerTexture       = ImGui::LoadImageFromMemory(reinterpret_cast<const ImU8 *>(banner.data()), banner.size());
+                if (oldTexture.valid()) { ImGui::UnloadImage(oldTexture); }
 
-                if (oldBannerTexture.valid()) { ImGui::UnloadImage(oldBannerTexture); }
+                return newTexture;
             };
 
             switch (theme) {
@@ -346,7 +365,8 @@ namespace hex::plugin::builtin {
                         ImGui::StyleColorsDark();
                         ImGui::StyleCustomColorsDark();
                         ImPlot::StyleColorsDark();
-                        changeBannerTexture("banner_dark.png");
+                        s_bannerTexture = changeTexture("banner_dark.png", s_bannerTexture);
+                        s_backdropTexture = changeTexture("backdrop_dark.png", s_backdropTexture);
 
                         break;
                     }
@@ -355,7 +375,8 @@ namespace hex::plugin::builtin {
                         ImGui::StyleColorsLight();
                         ImGui::StyleCustomColorsLight();
                         ImPlot::StyleColorsLight();
-                        changeBannerTexture("banner_light.png");
+                        s_bannerTexture = changeTexture("banner_light.png", s_bannerTexture);
+                        s_backdropTexture = changeTexture("backdrop_light.png", s_backdropTexture);
 
                         break;
                     }
@@ -364,7 +385,8 @@ namespace hex::plugin::builtin {
                         ImGui::StyleColorsClassic();
                         ImGui::StyleCustomColorsClassic();
                         ImPlot::StyleColorsClassic();
-                        changeBannerTexture("banner_dark.png");
+                        s_bannerTexture = changeTexture("banner_dark.png", s_bannerTexture);
+                        s_backdropTexture = changeTexture("backdrop_dark.png", s_backdropTexture);
 
                         break;
                     }
@@ -409,12 +431,11 @@ namespace hex::plugin::builtin {
 
                 ContentRegistry::Settings::write("hex.builtin.setting.imhex", "hex.builtin.setting.imhex.recent_files", recentFilesVector);
             }
+        });
 
-            {
-                if (!s_layoutConfigured) {
-                    initDefaultLayout();
-                }
-            }
+        EventManager::subscribe<EventProviderCreated>([](auto) {
+            if (!isAnyViewOpen())
+                loadDefaultLayout();
         });
 
         ContentRegistry::Interface::addMenuItem("hex.builtin.menu.file", 1075, [&] {

plugins/builtin/source/pattern_drawer.cpp

@@ -167,8 +167,9 @@ namespace hex {
     }
 
     void PatternDrawer::visit(pl::PatternString& pattern) {
-        this->createDefaultEntry(pattern, pattern.getFormattedValue(), pattern.getValue());
-    }
+        if (pattern.getSize() > 0)
+            this->createDefaultEntry(pattern, pattern.getFormattedValue(), pattern.getValue());
+        }
 
     void PatternDrawer::visit(pl::PatternStruct& pattern) {
         bool open = true;
@@ -237,9 +238,8 @@ namespace hex {
     }
 
     void PatternDrawer::visit(pl::PatternWideString& pattern) {
-        std::string utf8String = pattern.getValue();
-
-        this->createDefaultEntry(pattern, pattern.getFormattedValue(), utf8String);
+        if (pattern.getSize() > 0)
+            this->createDefaultEntry(pattern, pattern.getFormattedValue(), pattern.getValue());
     }
 
     void PatternDrawer::createDefaultEntry(const pl::Pattern &pattern, const std::string &value, pl::Token::Literal &&literal) const {