Merge branch 'master' into feature/clipboard_improvements

The bitmap visualizer has been simplified considerably. The previous version was designed to work with the TIM format which has some peculiarities that are not general enough. The current implementation has the following specifications.

. Whether colors are in a lookup table or part of the image itself they are always 32 bit R8G8B8A8.

. If using a color LUT the image then has indices as its element. Indices can have 16(32000 colors), 8 (256 colors) or 4(16 colors) bits each.

.For the cases 0f 16 and 8 bits, the data should be an array of N*M elements of the given size where N is the number of rows and M is the number of columns of the image.

. For the 4 bit case use an array of N*M/2 bytes so that each column contains two indices.

ToDo: Documentation, sample patterns and unit tests.

The 3-d visualizer can now handle textures from both the command line or the user interface and things should work as expected. A command line entry will be automatically displayed in the user interface, but changes will be applied immediately as you type or use the file picker. If the user interface text is deleted, then the command line texture will be used again.  If a texture is invalid for any reason, then the previous one, if any, will be still in use and an error message will be displayed until the problem is cleared. Valid textures are image files that the stb library can open.

.github/workflows/build.yml

@@ -6,6 +6,7 @@ on:
       - 'master'
       - 'releases/**'
       - 'tests/**'
+      - 'feature/**'
   pull_request:
   workflow_dispatch:
 
@@ -14,15 +15,22 @@ env:
 
 jobs:
 
-  # Windows build
-  win:
+  # Windows MINGW build
+  win_mingw:
     runs-on: windows-2022
     name: 🪟 Windows MINGW64
+
     defaults:
       run:
         shell: msys2 {0}
+
     env:
       CCACHE_DIR:      "${{ github.workspace }}/.ccache"
+
+    permissions:
+      id-token: write
+      attestations: write
+
     steps:
     - name: 🧰 Checkout
       uses: actions/checkout@v4
@@ -33,8 +41,8 @@ jobs:
       uses:  hendrikmuhs/ccache-action@v1
       id:    cache-ccache
       with:
-        key: ${{ runner.os }}-ccache-${{ github.run_id }}
-        restore-keys: ${{ runner.os }}-ccache
+        key: ${{ runner.os }}-mingw-ccache-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-mingw-ccache
         max-size: 1G
 
     - name: 🟦 Install msys2
@@ -81,11 +89,62 @@ jobs:
       run: |
         cd build
         ninja install
+
+    - name: 🪲 Create PDBs for MSI
+      run: |
+        cd build
+        
+        mkdir cv2pdb
+        cd cv2pdb
+        wget https://github.com/rainers/cv2pdb/releases/download/v0.52/cv2pdb-0.52.zip
+        unzip cv2pdb-0.52.zip
+        cd ..
+        
+        cv2pdb/cv2pdb.exe imhex.exe
+        cv2pdb/cv2pdb.exe imhex-gui.exe
+        cv2pdb/cv2pdb.exe libimhex.dll
+        
+        for plugin in plugins/*.hexplug; do
+          cv2pdb/cv2pdb.exe $plugin
+        done
+        
+        rm -rf cv2pdb
+
+    - name: 📦 Bundle MSI
+      run: |
+        cd build
         cpack
         mv ImHex-*.msi ../imhex-${{ env.IMHEX_VERSION }}-Windows-x86_64.msi
 
         echo "ImHex checks for the existence of this file to determine if it is running in portable mode. You should not delete this file" > $PWD/install/PORTABLE
 
+    - name: 🪲 Create PDBs for ZIP
+      run: |
+        cd build/install
+
+        mkdir cv2pdb
+        cd cv2pdb
+        wget https://github.com/rainers/cv2pdb/releases/download/v0.52/cv2pdb-0.52.zip
+        unzip cv2pdb-0.52.zip
+        cd ..
+        
+        cv2pdb/cv2pdb.exe imhex.exe
+        cv2pdb/cv2pdb.exe imhex-gui.exe
+        cv2pdb/cv2pdb.exe libimhex.dll
+        
+        for plugin in plugins/*.hexplug; do
+          cv2pdb/cv2pdb.exe $plugin
+        done
+        
+        rm -rf cv2pdb
+
+    - name: 🗝️ Generate build provenance attestations
+      uses: actions/attest-build-provenance@v2
+      if: ${{ github.event.repository.fork == false && github.event_name != 'pull_request' }}
+      with:
+        subject-path: |
+          imhex-*.msi
+
     - name: ⬆️ Upload Windows Installer
       uses: actions/upload-artifact@v4
       with:
@@ -119,15 +178,93 @@ jobs:
         path: |
           build/install/*
 
+  win_msvc:
+    runs-on: windows-2022
+    name: 🪟 Windows MSVC
+
+    env:
+      CCACHE_DIR:      "${{ github.workspace }}/.ccache"
+
+    permissions:
+      id-token: write
+      attestations: write
+
+    steps:
+      - name: 🧰 Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: 🫧 Setup Visual Studio Dev Environment
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: amd64
+
+      - name: 📜 Setup ccache
+        uses:  hendrikmuhs/ccache-action@v1
+        id:    cache-ccache
+        with:
+          key: ${{ runner.os }}-msvc-ccache-${{ github.run_id }}
+          restore-keys: ${{ runner.os }}-msvc-ccache
+          max-size: 1G
+
+      - name: 📦 Install vcpkg
+        uses: friendlyanon/setup-vcpkg@v1
+        with: { committish: 7e21420f775f72ae938bdeb5e6068f722088f06a }
+
+      - name: ⬇️ Install dependencies
+        run: |
+          cp dist/vcpkg.json vcpkg.json
+
+      - name: ⬇️ Install CMake and Ninja
+        uses: lukka/get-cmake@latest
+
+      - name: ⬇️ Install .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '8.0.100'
+
+      - name: 📜 Set version variable
+        run: |
+          "IMHEX_VERSION=$(Get-Content VERSION -Raw)" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+      # Windows cmake build
+      - name: 🛠️ Configure CMake
+        run: |
+          mkdir -p build
+                    
+          cmake -G "Ninja" -B build                                                   `
+            --preset vs2022                                                           `
+            -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake" `
+            -DCMAKE_C_COMPILER="$($(Get-Command cl.exe).Path)"                         `
+            -DCMAKE_CXX_COMPILER="$($(Get-Command cl.exe).Path)"                       `
+            -DCMAKE_C_COMPILER_LAUNCHER=ccache                                        `
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache                                      `
+            -DCMAKE_BUILD_TYPE="$env:BUILD_TYPE"                                      `
+            -DIMHEX_PATTERNS_PULL_MASTER=ON                                           `
+            -DIMHEX_COMMIT_HASH_LONG="$env:GITHUB_SHA"                                `
+            -DIMHEX_COMMIT_BRANCH="$($env:GITHUB_REF -replace '.*/', '')"             `
+            -DDOTNET_EXECUTABLE="C:/Program Files/dotnet/dotnet.exe"                  `
+            .
+
+      - name: 🛠️ Build
+        run: |
+          cd build
+          ninja
+
   win-plugin-template-test:
     runs-on: windows-2022
     name: 🧪 Plugin Template Test
+
     defaults:
       run:
         shell: msys2 {0}
-    needs: win
+
+    needs: win_mingw
+
     env:
       IMHEX_SDK_PATH: "${{ github.workspace }}/out/sdk"
+
     steps:
       - name: 🧰 Checkout ImHex
         uses: actions/checkout@v4
@@ -173,9 +310,13 @@ jobs:
           ninja
 
   # MacOS build
-  macos:
+  macos-x86:
     runs-on: macos-13
 
+    permissions:
+      id-token: write
+      attestations: write
+
     strategy:
       fail-fast: false
       matrix:
@@ -204,11 +345,17 @@ jobs:
         restore-keys: ${{ runner.os }}${{ matrix.suffix }}-ccache
         max-size: 1G
 
+    - name: Set Xcode version
+      run: sudo xcode-select -s /Library/Developer/CommandLineTools
+
     - name: ⬇️ Install dependencies
+      env:
+        # Make brew not display useless errors
+        HOMEBREW_TESTS: 1
       run: |
         brew reinstall python --quiet || true
-        brew link --overwrite --quiet python || true
-        brew bundle --no-lock --quiet --file dist/Brewfile || true
+        brew link --overwrite --quiet python 2>/dev/null || true
+        brew bundle --quiet --file dist/macOS/Brewfile || true
         rm -rf /usr/local/Cellar/capstone
 
     - name: ⬇️ Install classic glfw
@@ -299,19 +446,25 @@ jobs:
 
     - name: 📦 Create DMG
       run: |
-        set -x
-        mkdir bundle
-        mv build/install/ImHex.app bundle
-        cd bundle
-        ln -s /Applications Applications
-        cd ..
+        brew install graphicsmagick imagemagick
+        git clone https://github.com/sindresorhus/create-dmg
+        cd create-dmg
+        npm i && npm -g i
+        cd ../build/install
         for i in $(seq 1 10); do
-            if hdiutil create -volname "ImHex" -srcfolder bundle -ov -format UDZO imhex-${{ env.IMHEX_VERSION }}-macOS${{ matrix.suffix }}-x86_64.dmg; then
-                echo "Created dmg after ${i} attempts"
-                break
-            fi
-            sleep 10
+          create-dmg ImHex.app || true
+          if ls -d *.dmg 1>/dev/null 2>/dev/null; then
+            break;
+          fi
         done
+        mv *.dmg ../../imhex-${{ env.IMHEX_VERSION }}-macOS${{ matrix.suffix }}-x86_64.dmg
+
+    - name: 🗝️ Generate build provenance attestations
+      uses: actions/attest-build-provenance@v2
+      if: ${{ github.event.repository.fork == false && github.event_name != 'pull_request' }}
+      with:
+        subject-path: |
+          ./*.dmg
 
     - name: ⬆️ Upload DMG
       uses: actions/upload-artifact@v4
@@ -320,11 +473,13 @@ jobs:
         name: macOS DMG${{ matrix.suffix }} x86_64
         path: ./*.dmg
 
-  macos-arm64-build:
+  macos-arm64:
     runs-on: ubuntu-24.04
     name: 🍎 macOS 13 arm64
+
     outputs:
       IMHEX_VERSION: ${{ steps.build.outputs.IMHEX_VERSION }}
+
     steps:
     - name: 🧰 Checkout
       uses: actions/checkout@v4
@@ -348,6 +503,7 @@ jobs:
       run: |
         echo "IMHEX_VERSION=`cat VERSION`" >> $GITHUB_OUTPUT
         docker buildx build . -f dist/macOS/arm64.Dockerfile --progress=plain --build-arg 'JOBS=4' --build-arg "BUILD_TYPE=$(BUILD_TYPE)" --build-context imhex=$(pwd) --output out
+        cp resources/dist/macos/Entitlements.plist out/Entitlements.plist
 
     - name: ⬆️ Upload artifacts
       uses: actions/upload-artifact@v4
@@ -367,9 +523,15 @@ jobs:
   macos-arm64-package:
     runs-on: macos-13
     name: 🍎 macOS 13 arm64 Packaging
-    needs: macos-arm64-build
+    needs: macos-arm64
+
     env:
-      IMHEX_VERSION: ${{ needs.macos-arm64-build.outputs.IMHEX_VERSION }}
+      IMHEX_VERSION: ${{ needs.macos-arm64.outputs.IMHEX_VERSION }}
+
+    permissions:
+      id-token: write
+      attestations: write
+
     steps:
       - name: ⬇️ Download artifact
         uses: actions/download-artifact@v4
@@ -388,7 +550,7 @@ jobs:
           cd out
           mv imhex.app ImHex.app
           codesign --remove-signature ImHex.app
-          codesign --force --deep --sign - ImHex.app
+          codesign --force --deep --entitlements Entitlements.plist --sign - ImHex.app
 
       - name: 📁 Fix permissions
         run: |
@@ -404,19 +566,25 @@ jobs:
 
       - name: 📦 Create DMG
         run: |
-          set -x
-          mkdir bundle
-          mv out/ImHex.app bundle
-          cd bundle
-          ln -s /Applications Applications
-          cd ..
+          brew install graphicsmagick imagemagick
+          git clone https://github.com/sindresorhus/create-dmg
+          cd create-dmg
+          npm i && npm -g i
+          cd ../out
           for i in $(seq 1 10); do
-              if hdiutil create -volname "ImHex" -srcfolder bundle -ov -format UDZO imhex-${{ env.IMHEX_VERSION }}-macOS-arm64.dmg; then
-                  echo "Created dmg after ${i} attempts"
-                  break
-              fi
-              sleep 10
+            create-dmg ImHex.app || true
+            if ls -d *.dmg 1>/dev/null 2>/dev/null; then
+              break;
+            fi
           done
+          mv *.dmg ../imhex-${{ env.IMHEX_VERSION }}-macOS${{ matrix.suffix }}-arm64.dmg
+
+      - name: 🗝️ Generate build provenance attestations
+        uses: actions/attest-build-provenance@v2
+        if: ${{ github.event.repository.fork == false && github.event_name != 'pull_request' }}
+        with:
+          subject-path: |
+            ./*.dmg
 
       - name: ⬆️ Upload DMG
         uses: actions/upload-artifact@v4
@@ -433,6 +601,7 @@ jobs:
         include:
           - release_num: "24.04"
           - release_num: "24.10"
+          - release_num: "25.04"
 
     name: 🐧 Ubuntu ${{ matrix.release_num }}
     runs-on: ubuntu-24.04
@@ -441,6 +610,10 @@ jobs:
       image: "ubuntu:${{ matrix.release_num }}"
       options: --privileged
 
+    permissions:
+      id-token: write
+      attestations: write
+
     steps:
       - name: ⬇️ Install setup dependencies
         run: apt update && apt install -y git curl
@@ -498,9 +671,16 @@ jobs:
       - name: 📦 Bundle DEB
         run: |
           cp -r build/DEBIAN build/DebDir
-          dpkg-deb -Zgzip --build build/DebDir
+          dpkg-deb -Zzstd --build build/DebDir
           mv build/DebDir.deb imhex-${{ env.IMHEX_VERSION }}-Ubuntu-${{ matrix.release_num }}-x86_64.deb
 
+      - name: 🗝️ Generate build provenance attestations
+        uses: actions/attest-build-provenance@v2
+        if: ${{ github.event.repository.fork == false && github.event_name != 'pull_request' }}
+        with:
+          subject-path: |
+            ./*.deb
+
       - name: ⬆️ Upload DEB
         uses: actions/upload-artifact@v4
         with:
@@ -510,8 +690,26 @@ jobs:
 
   # AppImage build
   appimage:
-    runs-on: ubuntu-24.04
-    name: ⬇️ AppImage
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - architecture: "x86_64"
+            architecture_package: "amd64"
+            architecture_appimage_builder: "x86_64"
+            image: ubuntu-24.04
+          - architecture: "arm64"
+            architecture_package: "arm64"
+            architecture_appimage_builder: "aarch64"
+            image: ubuntu-24.04-arm
+
+    runs-on: ${{ matrix.image }}
+    name: ⬇️ AppImage ${{ matrix.architecture }}
+
+    permissions:
+      id-token: write
+      attestations: write
+
     steps:
       - name: 🧰 Checkout
         uses: actions/checkout@v4
@@ -522,8 +720,8 @@ jobs:
         uses: actions/cache@v4
         with:
           path: cache
-          key: appimage-ccache-${{ github.run_id }}
-          restore-keys: appimage-cache
+          key: appimage-ccache-${{ matrix.architecture }}-${{ github.run_id }}
+          restore-keys: appimage-ccache-${{ matrix.architecture }}
 
       - name: 🐳 Inject /cache into docker
         uses: reproducible-containers/buildkit-cache-dance@v2
@@ -533,22 +731,31 @@ jobs:
 
       - name: 🛠️ Build using docker
         run: |
-          docker buildx build . -f dist/appimage/Dockerfile --progress=plain --build-arg "BUILD_TYPE=$BUILD_TYPE" \
-          --build-arg "GIT_COMMIT_HASH=$GITHUB_SHA" --build-arg "GIT_BRANCH=${GITHUB_REF##*/}" --output out
+          docker buildx build . -f dist/AppImage/Dockerfile --progress=plain --build-arg "BUILD_TYPE=$BUILD_TYPE" \
+          --build-arg "GIT_COMMIT_HASH=$GITHUB_SHA" --build-arg "GIT_BRANCH=${GITHUB_REF##*/}" \
+          --build-arg "ARCHITECTURE_PACKAGE=${{ matrix.architecture_package }}" --build-arg "ARCHITECTURE_FILE_NAME=${{ matrix.architecture }}" --build-arg "ARCHITECTURE_APPIMAGE_BUILDER=${{ matrix.architecture_appimage_builder }}" \
+          --output out
 
+      - name: 🗝️ Generate build provenance attestations
+        uses: actions/attest-build-provenance@v2
+        if: ${{ github.event.repository.fork == false && github.event_name != 'pull_request' }}
+        with:
+          subject-path: |
+            out/*.AppImage
+            out/*.AppImage.zsync
 
       - name: ⬆️ Upload AppImage
         uses: actions/upload-artifact@v4
         with:
           if-no-files-found: error
-          name: Linux AppImage x86_64
+          name: Linux AppImage ${{ matrix.architecture }}
           path: 'out/*.AppImage'
 
       - name: ⬆️ Upload AppImage zsync
         uses: actions/upload-artifact@v4
         with:
           if-no-files-found: error
-          name: Linux AppImage zsync x86_64
+          name: Linux AppImage zsync ${{ matrix.architecture }}
           path: 'out/*.AppImage.zsync'
 
   # ArchLinux build
@@ -559,6 +766,10 @@ jobs:
     container:
       image: archlinux:base-devel
 
+    permissions:
+      id-token: write
+      attestations: write
+
     steps:
       - name: ⬇️ Update all packages
         run: |
@@ -642,6 +853,13 @@ jobs:
           rm *imhex-bin-debug* # rm debug package which is created for some reason
           mv *.pkg.tar.zst imhex-${{ env.IMHEX_VERSION }}-ArchLinux-x86_64.pkg.tar.zst
 
+      - name: 🗝️ Generate build provenance attestations
+        uses: actions/attest-build-provenance@v2
+        if: ${{ github.event.repository.fork == false && github.event_name != 'pull_request' }}
+        with:
+          subject-path: |
+            build/imhex-${{ env.IMHEX_VERSION }}-ArchLinux-x86_64.pkg.tar.zst
+
       - name: ⬆️ Upload imhex-archlinux.pkg.tar.zst
         uses: actions/upload-artifact@v4
         with:
@@ -660,14 +878,14 @@ jobs:
             mock_release: rawhide
             release_num: rawhide
             mock_config: fedora-rawhide
+          - name: Fedora
+            mock_release: f42
+            release_num: 42
+            mock_config: fedora-42
           - name: Fedora
             mock_release: f41
             release_num: 41
             mock_config: fedora-41
-          - name: Fedora
-            mock_release: f40
-            release_num: 40
-            mock_config: fedora-40
           - name: RHEL-AlmaLinux
             mock_release: epel9
             release_num: 9
@@ -680,6 +898,10 @@ jobs:
       image: "almalinux:9"
       options: --privileged --pid=host --security-opt apparmor=unconfined
 
+    permissions:
+      id-token: write
+      attestations: write
+
     steps:
       # This, together with the `--pid=host --security-opt apparmor=unconfined` docker options is required to allow
       # fedpkg to work inside a Docker container running on Ubuntu again.
@@ -709,7 +931,7 @@ jobs:
           path: /var/cache/dnf
           key: ${{ matrix.mock_release }}-dnf-${{ github.run_id }}
           restore-keys: |
-            ${{ matrix.mock_release }}-dnf-
+            ${{ matrix.mock_release }}-dnf
 
       - name: ⬇️ Update all packages and install dependencies
         run: |
@@ -775,6 +997,13 @@ jobs:
           mv $GITHUB_WORKSPACE/results_imhex/${{ env.IMHEX_VERSION }}/*/imhex-${{ env.IMHEX_VERSION }}-0.*.x86_64.rpm \
           $GITHUB_WORKSPACE/imhex-${{ env.IMHEX_VERSION }}-${{ matrix.name }}-${{ matrix.release_num }}-x86_64.rpm
 
+      - name: 🗝️ Generate build provenance attestations
+        uses: actions/attest-build-provenance@v2
+        if: ${{ github.event.repository.fork == false && github.event_name != 'pull_request' }}
+        with:
+          subject-path: |
+            imhex-${{ env.IMHEX_VERSION }}-${{ matrix.name }}-${{ matrix.release_num }}-x86_64.rpm
+
       - name: ⬆️ Upload RPM
         uses: actions/upload-artifact@v4
         with:
@@ -782,3 +1011,93 @@ jobs:
           name: ${{ matrix.name }} ${{ matrix.release_num }} RPM x86_64
           path: |
             imhex-${{ env.IMHEX_VERSION }}-${{ matrix.name }}-${{ matrix.release_num }}-x86_64.rpm
+
+  webassembly-build:
+    runs-on: ubuntu-24.04
+    name: 🌍 Web
+    permissions:
+      pages: write
+      id-token: write
+      actions: write
+    steps:
+      - name: 🧰 Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: 📁 Restore docker /cache
+        uses: actions/cache@v4
+        with:
+          path: cache
+          key: web-cache-${{ hashFiles('**/CMakeLists.txt') }}
+
+      - name: 🐳 Inject /cache into docker
+        uses: reproducible-containers/buildkit-cache-dance@v2
+        with:
+          cache-source: cache
+          cache-target: /cache
+
+      - name: 🛠️ Build using docker
+        run: |
+          mkdir -p out/nightly
+          docker buildx build . -f dist/web/Dockerfile --progress=plain --build-arg 'JOBS=4' --output out/nightly --target raw
+
+      - name: ⬇️ Download Release
+        uses: robinraju/release-downloader@v1
+        with:
+          latest: true
+          fileName: 'imhex-*-Web.zip'
+
+      - name: 🔨 Fix permissions
+        run: |
+          unzip imhex-*-Web.zip -d out
+          chmod -c -R +rX "out/"
+
+      - name: ⬆️ Upload artifacts
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: out/
+
+      - name: 🔨 Copy necessary files
+        run: |
+          cp dist/web/serve.py out/nightly/start_imhex_web.py
+
+      - name: ⬆️ Upload package
+        uses: actions/upload-artifact@v4
+        with:
+          if-no-files-found: error
+          name: ImHex Web
+          path: out/nightly/*
+
+        # See https://github.com/actions/cache/issues/342#issuecomment-1711054115
+      - name: 🗑️ Delete old cache
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh extension install actions/gh-actions-cache || true
+          gh actions-cache delete "build-web-cache" --confirm || true
+
+  webassembly-deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    permissions:
+      pages: write
+      id-token: write
+      actions: write
+    name: 📃 Deploy to GitHub Pages
+    runs-on: ubuntu-24.04
+
+    if: ${{ github.ref == 'refs/heads/master' && github.event.repository.fork == false }}
+    needs: webassembly-build
+
+    steps:
+      - name: 🌍 Deploy WebAssembly Build to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
+
+      - name: 🗑️ Delete artifact
+        uses: geekyeggo/delete-artifact@v5
+        with:
+          name: github-pages

.github/workflows/build_web.yml

@@ -1,79 +0,0 @@
-name: Build for the web
-
-on:
-  push:
-    branches:
-      - 'master'
-      - 'releases/**'
-      - 'tests/**'
-  pull_request:
-  workflow_dispatch:
-
-env:
-  BUILD_TYPE: Release
-
-permissions:
-  pages: write
-  id-token: write
-  actions: write
-
-jobs:
-
-  build:
-    runs-on: ubuntu-24.04
-    name: 🌍 WebAssembly
-    steps:
-    - name: 🧰 Checkout
-      uses: actions/checkout@v4
-      with:
-        submodules: recursive
-    
-    - name: 📁 Restore docker /cache
-      uses: actions/cache@v4
-      with:
-        path: cache
-        key: web-cache-${{ hashFiles('**/CMakeLists.txt') }}
-    
-    - name: 🐳 Inject /cache into docker
-      uses: reproducible-containers/buildkit-cache-dance@v2
-      with:
-        cache-source: cache
-        cache-target: /cache
-
-    - name: 🛠️ Build using docker
-      run: |
-        docker buildx build . -f dist/web/Dockerfile --progress=plain --build-arg 'JOBS=4' --output out --target raw
-
-    - name: 🔨 Fix permissions
-      run: |
-        chmod -c -R +rX "out/"
-
-    - name: ⬆️ Upload artifacts
-      uses: actions/upload-pages-artifact@v3
-      with:
-        path: out/
-
-      # See https://github.com/actions/cache/issues/342#issuecomment-1711054115
-    - name: 🗑️ Delete old cache
-      continue-on-error: true
-      env:
-        GH_TOKEN: ${{ github.token }}
-      run: |
-          gh extension install actions/gh-actions-cache || true
-          gh actions-cache delete "build-web-cache" --confirm || true
-
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-      
-    name: 📃 Deploy to GitHub Pages
-    runs-on: ubuntu-24.04
-
-    if: ${{ github.ref == 'refs/heads/master' && github.event.repository.fork == false }}
-    needs: build
-
-    steps:
-      - name: 🌍 Deploy
-        id: deployment
-        uses: actions/deploy-pages@v4

.github/workflows/release.yml

@@ -63,7 +63,7 @@ jobs:
           token: ${{ secrets.RELEASE_TOKEN }}
 
   release-upload-artifacts:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     name: Release Upload Artifacts
 
     steps:
@@ -117,6 +117,8 @@ jobs:
         run: |
           mv "Windows Portable x86_64.zip" imhex-${{ env.IMHEX_VERSION }}-Windows-Portable-x86_64.zip
           mv "Windows Portable NoGPU x86_64.zip" imhex-${{ env.IMHEX_VERSION }}-Windows-Portable-NoGPU-x86_64.zip
+          mv "ImHex Web.zip" imhex-${{ env.IMHEX_VERSION }}-Web.zip
+          rm artifact.tar
 
       - name: ⬆️ Upload everything to release
         uses: softprops/action-gh-release@4634c16e79c963813287e889244c50009e7f0981

.github/workflows/stale_issues.yml

@@ -6,7 +6,7 @@ on:
 
 jobs:
   close-issues:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     permissions:
       issues: write
       pull-requests: write

.github/workflows/tests.yml

@@ -6,6 +6,7 @@ on:
       - 'master'
       - 'releases/**'
       - 'tests/**'
+      - 'feature/**'
   pull_request:
     branches:
       - 'master'

.gitignore

@@ -7,6 +7,8 @@ build*/
 local/
 venv/
 .cache/
+install/
+out/
 
 *.mgc
 *.kdev4
@@ -14,3 +16,6 @@ imgui.ini
 .DS_Store
 CMakeUserPresets.json
 Brewfile.lock.json
+
+.vs/
+vcpkg.json

.gitmodules

@@ -24,11 +24,11 @@
     ignore = dirty
 [submodule "lib/third_party/edlib"]
 	path = lib/third_party/edlib
-	url = https://github.com/Martinsos/edlib
+	url = https://github.com/blawrence-ont/edlib
 	ignore = dirty
 [submodule "lib/third_party/lunasvg"]
 	path = lib/third_party/lunasvg
-	url = https://github.com/WerWolv/lunasvg
+	url = https://github.com/sammycage/lunasvg
 	ignore = dirty
 
 [submodule "lib/external/libromfs"]
@@ -43,4 +43,10 @@
 
 [submodule "lib/third_party/HashLibPlus"]
 	path = lib/third_party/HashLibPlus
-    url = https://github.com/WerWolv/HashLibPlus
+    url = https://github.com/WerWolv/HashLibPlus
+[submodule "lib/external/disassembler"]
+	path = lib/external/disassembler
+	url = https://github.com/WerWolv/Disassembler
+[submodule "lib/third_party/clip"]
+	path = lib/third_party/clip
+	url = https://github.com/dacap/clip

CMakeLists.txt

@@ -22,6 +22,7 @@ option(IMHEX_ENABLE_STD_ASSERTS         "Enable debug asserts in the C++ std lib
 option(IMHEX_ENABLE_UNIT_TESTS          "Enable building unit tests"                                                            OFF)
 option(IMHEX_ENABLE_PRECOMPILED_HEADERS "Enable precompiled headers"                                                            OFF)
 option(IMHEX_COMPRESS_DEBUG_INFO        "Compress debug information"                                                            ON )
+option(IMHEX_ENABLE_CXX_MODULES         "Enable C++20 Module compilation. Testing only!"                                        OFF)
 
 set(IMHEX_BASE_FOLDER "${CMAKE_CURRENT_SOURCE_DIR}")
 set(CMAKE_MODULE_PATH "${IMHEX_BASE_FOLDER}/cmake/modules")
@@ -31,6 +32,7 @@ include("${IMHEX_BASE_FOLDER}/cmake/ide_helpers.cmake")
 
 # Basic compiler and cmake configurations
 set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_SCAN_FOR_MODULES ${IMHEX_ENABLE_CXX_MODULES})
 set(CMAKE_INCLUDE_DIRECTORIES_BEFORE ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 include("${IMHEX_BASE_FOLDER}/cmake/build_helpers.cmake")
@@ -70,6 +72,7 @@ addBundledLibraries()
 add_subdirectory(lib/libimhex)
 add_subdirectory(main)
 addPluginDirectories()
+add_subdirectory(lib/trace)
 
 # Add unit tests
 if (IMHEX_ENABLE_UNIT_TESTS)
@@ -81,7 +84,6 @@ if (IMHEX_ENABLE_UNIT_TESTS)
 endif ()
 
 # Configure more resources that will be added to the install package
-generatePDBs()
 generateSDKDirectory()
 
 # Handle package generation

CMakePresets.json

@@ -45,6 +45,15 @@
 
         "IMHEX_IDE_HELPERS_OVERRIDE_XCODE_COMPILER": "ON"
       }
+    },
+    {
+      "name": "vs2022",
+      "displayName": "Visual Studio 2022",
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/build/${presetName}",
+      "cacheVariables": {
+        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
+      }
     }
   ],
   "buildPresets": [

INSTALL.md

@@ -27,6 +27,11 @@ chmod +x imhex-*.AppImage
 ./imhex-*.AppImage
 ```
 
+If you're experiencing glib / libgtk assertion failures, you might need to setup your `XDG_DATA_DIRS` env var correctly. In this case, run the following command before executing the AppImage. (See issue [ImHex/#2038](https://github.com/WerWolv/ImHex/issues/2038))
+```bash
+export XDG_DATA_DIRS="/usr/local/share:/usr/share"
+```
+
 #### Flatpak
 To install the Flatpak, make sure you have the Flathub repository added to your system. Then simply run the following command:
 

README.md

@@ -38,8 +38,8 @@ If you like my work, please consider supporting me on GitHub Sponsors, Patreon o
 </p>
 
 ## Screenshots
-![Hex editor, patterns and data information](https://github.com/WerWolv/ImHex/assets/10835354/4f358238-2d27-41aa-9015-a2c6cc3708cf)
-![Bookmarks, disassembler and data processor](https://github.com/WerWolv/ImHex/assets/10835354/183bc2cc-2439-4ded-b4c5-b140e19fc92f)
+![Hex editor, patterns and data information](https://github.com/user-attachments/assets/902a7c4c-410d-490f-999e-14c856fec027)
+![Bookmarks, data information, find view and data processor](https://github.com/user-attachments/assets/58eefa1f-31c9-4bb8-a1c1-8cdd8ddbd29f)
 
 <details>
 <summary><strong>More Screenshots</strong></summary>
@@ -328,12 +328,12 @@ To use ImHex, the following minimal system requirements need to be met.
     - RHEL/AlmaLinux
     - Arch Linux
     - Basically any other distro will work as well when compiling ImHex from sources.
-- **CPU**: x86_64 (64 Bit)
+- **CPU**: Officially supported are x86_64 and ARM64, though any Little Endian 64 bit CPU should work.
 - **GPU**: OpenGL 3.0 or higher 
   - Integrated Intel HD iGPUs are supported, however certain drivers are known to cause various graphical artifacts, especially on Windows. Use at your own risk.
   - In case you don't have a GPU available, there are software rendered releases available for Windows and macOS
-- **RAM**: 256MB, more may be required for more complicated analysis
-- **Storage**: 150MB
+- **RAM**: ~150MiB, more is required for more complex analysis
+- **Storage**: 150MiB
 
 ## Installing
 
@@ -342,8 +342,10 @@ Information on how to install ImHex can be found in the [Install](/INSTALL.md) g
 ## Compiling
 
 To compile ImHex on any platform, GCC (or Clang) is required with a version that supports C++23 or higher. 
-On macOS, Clang is also required to compile some ObjC code.
-All releases are being built using latest available GCC.
+Windows and Linux releases are being built using latest available GCC.
+MacOS releases are being built using latest available LLVM Clang.
+
+Important to note is, the MSVC and AppleClang compilers are both **NOT** supported since they're both generally severely outdated and lack features GCC and LLVM Clang have.
 
 > [!NOTE]
 > Many dependencies are bundled into the repository using submodules so make sure to clone it using the `--recurse-submodules` option.

VERSION

@@ -1 +1 @@
-1.36.2
+1.38.0.WIP

cmake/build_helpers.cmake

@@ -1,3 +1,73 @@
+# Some libraries we use set the BUILD_SHARED_LIBS variable to ON, which causes CMake to
+# display a warning about options being set using set() instead of option().
+# Explicitly set the policy to NEW to suppress the warning.
+set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
+
+set(CMAKE_POLICY_DEFAULT_CMP0063 NEW)
+
+if (POLICY CMP0177)
+    set(CMAKE_POLICY_DEFAULT_CMP0177 OLD)
+    cmake_policy(SET CMP0177 OLD)
+endif()
+
+function(getTarget target type)
+    get_target_property(IMPORTED_TARGET ${target} IMPORTED)
+    if (IMPORTED_TARGET)
+        set(${type} INTERFACE PARENT_SCOPE)
+    else()
+        set(${type} PRIVATE PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(addCFlag)
+    if (ARGC EQUAL 1)
+        add_compile_options($<$<COMPILE_LANGUAGE:C>:${ARGV0}>)
+    elseif (ARGC EQUAL 2)
+        getTarget(${ARGV1} TYPE)
+        target_compile_options(${ARGV1} ${TYPE} $<$<COMPILE_LANGUAGE:C>:${ARGV0}>)
+    endif()
+endfunction()
+
+function(addCXXFlag)
+    if (ARGC EQUAL 1)
+        add_compile_options($<$<COMPILE_LANGUAGE:CXX>:${ARGV0}>)
+    elseif (ARGC EQUAL 2)
+        getTarget(${ARGV1} TYPE)
+        target_compile_options(${ARGV1} ${TYPE} $<$<COMPILE_LANGUAGE:CXX>:${ARGV0}>)
+    endif()
+endfunction()
+
+function(addObjCFlag)
+    if (ARGC EQUAL 1)
+        add_compile_options($<$<COMPILE_LANGUAGE:OBJC>:${ARGV0}>)
+    elseif (ARGC EQUAL 2)
+        getTarget(${ARGV1} TYPE)
+        target_compile_options(${ARGV1} ${TYPE} $<$<COMPILE_LANGUAGE:OBJC>:${ARGV0}>)
+    endif()
+endfunction()
+
+function(addLinkerFlag)
+    if (ARGC EQUAL 1)
+        add_link_options(${ARGV0})
+    elseif (ARGC EQUAL 2)
+        getTarget(${ARGV1} TYPE)
+        target_link_options(${ARGV1} ${TYPE} ${ARGV0})
+    endif()
+endfunction()
+
+function(addCCXXFlag)
+    addCFlag(${ARGV0} ${ARGV1})
+    addCXXFlag(${ARGV0} ${ARGV1})
+endfunction()
+
+function(addCommonFlag)
+    addCFlag(${ARGV0} ${ARGV1})
+    addCXXFlag(${ARGV0} ${ARGV1})
+    addObjCFlag(${ARGV0} ${ARGV1})
+endfunction()
+
+set(CMAKE_WARN_DEPRECATED OFF CACHE BOOL "Disable deprecated warnings" FORCE)
+
 include(FetchContent)
 
 if(IMHEX_STRIP_RELEASE)
@@ -59,7 +129,9 @@ macro(detectOS)
         set(CMAKE_INSTALL_LIBDIR ".")
         set(PLUGINS_INSTALL_LOCATION "plugins")
         add_compile_definitions(WIN32_LEAN_AND_MEAN)
+        add_compile_definitions(NOMINMAX)
         add_compile_definitions(UNICODE)
+        add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
     elseif (APPLE)
         add_compile_definitions(OS_MACOS)
         set(CMAKE_INSTALL_BINDIR ".")
@@ -110,7 +182,7 @@ macro(configurePackingResources)
             set(CPACK_WIX_PRODUCT_ICON "${PROJECT_SOURCE_DIR}/resources/dist/windows/icon.ico")
             set(CPACK_WIX_UI_BANNER "${PROJECT_SOURCE_DIR}/resources/dist/windows/wix_banner.png")
             set(CPACK_WIX_UI_DIALOG "${PROJECT_SOURCE_DIR}/resources/dist/windows/wix_dialog.png")
-            set(CPACK_WIX_CULTURES "en-US;de-DE;ja-JP;it-IT;pt-BR;zh-CN;zh-TW")
+            set(CPACK_WIX_CULTURES "en-US;de-DE;ja-JP;it-IT;pt-BR;zh-CN;zh-TW;ru-RU")
             set(CPACK_PACKAGE_INSTALL_DIRECTORY "ImHex")
             set_property(INSTALL "$<TARGET_FILE_NAME:main>"
                     PROPERTY CPACK_START_MENU_SHORTCUTS "ImHex"
@@ -226,7 +298,7 @@ macro(createPackage)
         install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/LICENSE DESTINATION ${CMAKE_INSTALL_PREFIX}/share/licenses/imhex)
         install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/dist/imhex.desktop DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications)
         install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/dist/imhex.mime.xml DESTINATION ${CMAKE_INSTALL_PREFIX}/share/mime/packages RENAME imhex.xml)
-        install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/resources/icon.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/pixmaps RENAME imhex.png)
+        install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/resources/icon.svg DESTINATION ${CMAKE_INSTALL_PREFIX}/share/pixmaps RENAME imhex.svg)
         downloadImHexPatternsFiles("./share/imhex")
 
         # install AppStream file
@@ -257,6 +329,7 @@ macro(createPackage)
 
             install(FILES ${IMHEX_ICON} DESTINATION "${CMAKE_INSTALL_PREFIX}/${BUNDLE_NAME}/Contents/Resources")
             install(TARGETS main BUNDLE DESTINATION ".")
+            install(TARGETS updater BUNDLE DESTINATION ".")
 
             # Update library references to make the bundle portable
             postprocess_bundle(imhex_all main)
@@ -309,6 +382,10 @@ endfunction()
 macro(configureCMake)
     message(STATUS "Configuring ImHex v${IMHEX_VERSION}")
 
+    if (DEFINED CMAKE_TOOLCHAIN_FILE)
+        message(STATUS "Using toolchain file: \"${CMAKE_TOOLCHAIN_FILE}\"")
+    endif()
+
     set(CMAKE_POSITION_INDEPENDENT_CODE ON CACHE BOOL "Enable position independent code for all targets" FORCE)
 
     # Configure use of recommended build tools
@@ -343,9 +420,9 @@ macro(configureCMake)
         if (LD_LLD_PATH)
             set(CMAKE_LINKER ${LD_LLD_PATH})
 
-            if (NOT XCODE)
-                set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fuse-ld=lld")
-                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fuse-ld=lld")
+            if (NOT XCODE AND NOT MSVC)
+                set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} -fuse-ld=lld)
+                set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} -fuse-ld=lld)
             endif()
         else ()
             message(WARNING "lld not found, using default linker!")
@@ -370,15 +447,6 @@ macro(configureCMake)
             message(WARNING "LTO is not supported: ${output_error}")
         endif ()
     endif ()
-
-    # Some libraries we use set the BUILD_SHARED_LIBS variable to ON, which causes CMake to
-    # display a warning about options being set using set() instead of option().
-    # Explicitly set the policy to NEW to suppress the warning.
-    set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
-
-    set(CMAKE_POLICY_DEFAULT_CMP0063 NEW)
-
-    set(CMAKE_WARN_DEPRECATED OFF CACHE BOOL "Disable deprecated warnings" FORCE)
 endmacro()
 
 function(configureProject)
@@ -434,6 +502,8 @@ function(verifyCompiler)
         message(FATAL_ERROR "ImHex requires GCC 12.0.0 or newer. Please use the latest GCC version.")
     elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "17.0.0")
         message(FATAL_ERROR "ImHex requires Clang 17.0.0 or newer. Please use the latest Clang version.")
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+        
     elseif (NOT (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
         message(FATAL_ERROR "ImHex can only be compiled with GCC or Clang. ${CMAKE_CXX_COMPILER_ID} is not supported.")
     endif()
@@ -501,16 +571,16 @@ function(downloadImHexPatternsFiles dest)
 
         # Maybe patterns are cloned to a subdirectory
         if (NOT EXISTS ${imhex_patterns_SOURCE_DIR})
-            set(imhex_patterns_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ImHex-Patterns")        
+            set(imhex_patterns_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ImHex-Patterns")
         endif()
 
         # Or a sibling directory
         if (NOT EXISTS ${imhex_patterns_SOURCE_DIR})
-            set(imhex_patterns_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../ImHex-Patterns")        
+            set(imhex_patterns_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../ImHex-Patterns")
         endif()
     endif ()
 
-    if (NOT EXISTS ${imhex_patterns_SOURCE_DIR}) 
+    if (NOT EXISTS ${imhex_patterns_SOURCE_DIR})
         message(WARNING "Failed to locate ImHex-Patterns repository, some resources will be missing during install!")
     elseif(XCODE)
         # The Xcode build has multiple configurations, which each need a copy of these files
@@ -553,34 +623,67 @@ macro(setupDebugCompressionFlag)
         elseif (COMPRESS_AVAILABLE_COMPILER AND COMPRESS_AVAILABLE_LINKER)
             message("Using default compression for debug info because both compiler and linker support it")
             set(DEBUG_COMPRESSION_FLAG "-gz" CACHE STRING "Cache to use for debug info compression")
+        else()
+            set(DEBUG_COMPRESSION_FLAG "" CACHE STRING "Cache to use for debug info compression")
         endif()
     endif()
 
-    set(IMHEX_COMMON_FLAGS "${IMHEX_COMMON_FLAGS} ${DEBUG_COMPRESSION_FLAG}")
+    addCommonFlag(${DEBUG_COMPRESSION_FLAG})
 endmacro()
 
 macro(setupCompilerFlags target)
-    # IMHEX_COMMON_FLAGS: flags common for C, C++, Objective C, etc.. compilers
+    if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+        addCommonFlag("/W4" ${target})
+        addCommonFlag("/wd4127" ${target}) # conditional expression is constant
+        addCommonFlag("/wd4242" ${target}) # 'identifier': conversion from 'type1' to 'type2', possible loss of data
+        addCommonFlag("/wd4244" ${target}) # 'conversion': conversion from 'type1' to 'type2', possible loss of data
+        addCommonFlag("/wd4267" ${target}) # 'var': conversion from 'size_t' to 'type', possible loss of data
+        addCommonFlag("/wd4305" ${target}) # truncation from 'double' to 'float'
+        addCommonFlag("/wd4996" ${target}) # 'function': was declared deprecated
+        addCommonFlag("/wd5244" ${target}) # 'include' in the purview of module 'module' appears erroneous
+
+        if (IMHEX_STRICT_WARNINGS)
+            addCommonFlag("/WX" ${target})
+        endif()
+    elseif (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+        addCommonFlag("-Wall" ${target})
+        addCommonFlag("-Wextra" ${target})
+        addCommonFlag("-Wpedantic" ${target})
 
-    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
         # Define strict compilation flags
         if (IMHEX_STRICT_WARNINGS)
-            set(IMHEX_COMMON_FLAGS "${IMHEX_COMMON_FLAGS} -Wall -Wextra -Wpedantic -Werror")
+             addCommonFlag("-Werror" ${target})
         endif()
 
         if (UNIX AND NOT APPLE AND CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-            set(IMHEX_COMMON_FLAGS "${IMHEX_COMMON_FLAGS} -rdynamic")
+            addCommonFlag("-rdynamic" ${target})
         endif()
 
-        set(IMHEX_CXX_FLAGS "-fexceptions -frtti")
+        addCXXFlag("-fexceptions" ${target})
+        addCXXFlag("-frtti" ${target})
+        addCommonFlag("-fno-omit-frame-pointer" ${target})
 
         # Disable some warnings
-        set(IMHEX_C_CXX_FLAGS "-Wno-array-bounds -Wno-deprecated-declarations -Wno-unknown-pragmas")
+        addCCXXFlag("-Wno-array-bounds" ${target})
+        addCCXXFlag("-Wno-deprecated-declarations" ${target})
+        addCCXXFlag("-Wno-unknown-pragmas" ${target})
+        addCXXFlag("-Wno-include-angled-in-module-purview" ${target})
+
+        # Enable hardening flags
+        if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+            addCommonFlag("-U_FORTIFY_SOURCE" ${target})
+            addCommonFlag("-D_FORTIFY_SOURCE=3" ${target})
+
+            if (NOT EMSCRIPTEN)
+                addCommonFlag("-fstack-protector-strong" ${target})
+            endif()
+        endif()
+
     endif()
 
     if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-        if (IMHEX_ENABLE_UNITY_BUILD AND WIN32)
-            set(IMHEX_COMMON_FLAGS "${IMHEX_COMMON_FLAGS} -Wa,-mbig-obj")
+        if (WIN32)
+            addLinkerFlag("-Wa,mbig-obj" ${target})
         endif ()
     endif()
 
@@ -588,36 +691,51 @@ macro(setupCompilerFlags target)
         execute_process(COMMAND brew --prefix llvm OUTPUT_VARIABLE LLVM_PREFIX OUTPUT_STRIP_TRAILING_WHITESPACE)
         set(CMAKE_EXE_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS} -L${LLVM_PREFIX}/lib/c++")
         set(CMAKE_SHARED_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS} -L${LLVM_PREFIX}/lib/c++")
-        set(IMHEX_C_CXX_FLAGS "-Wno-unknown-warning-option")
+        addCCXXFlag("-Wno-unknown-warning-option" ${target})
+
+        if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+            add_compile_definitions(_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG)
+        else()
+            add_compile_definitions(_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE)
+        endif()
+    endif()
+
+    if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+        addCommonFlag("/bigobj" ${target})
+        addCFlag("/std:clatest" ${target})
+        addCXXFlag("/std:c++latest" ${target})
     endif()
 
     # Disable some warnings for gcc
-    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-        set(IMHEX_C_CXX_FLAGS "${IMHEX_C_CXX_FLAGS} -Wno-restrict -Wno-stringop-overread -Wno-stringop-overflow -Wno-dangling-reference")
+    if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+        addCCXXFlag("-Wno-restrict" ${target})
+        addCCXXFlag("-Wno-stringop-overread" ${target})
+        addCCXXFlag("-Wno-stringop-overflow" ${target})
+        addCCXXFlag("-Wno-dangling-reference" ${target})
     endif()
 
     # Define emscripten-specific disabled warnings
     if (EMSCRIPTEN)
-        set(IMHEX_C_CXX_FLAGS "${IMHEX_C_CXX_FLAGS} -pthread -Wno-dollar-in-identifier-extension -Wno-pthreads-mem-growth")
+        addCCXXFlag("-pthread" ${target})
+        addCCXXFlag("-Wno-dollar-in-identifier-extension" ${target})
+        addCCXXFlag("-Wno-pthreads-mem-growth" ${target})
     endif ()
 
     if (IMHEX_COMPRESS_DEBUG_INFO)
         setupDebugCompressionFlag()
     endif()
 
-    # Set actual CMake flags
-    set_target_properties(${target} PROPERTIES COMPILE_FLAGS "${IMHEX_COMMON_FLAGS} ${IMHEX_C_CXX_FLAGS}")
-    set(CMAKE_C_FLAGS    "${CMAKE_C_FLAGS}    ${IMHEX_COMMON_FLAGS} ${IMHEX_C_CXX_FLAGS}")
-    set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS}  ${IMHEX_COMMON_FLAGS} ${IMHEX_C_CXX_FLAGS}  ${IMHEX_CXX_FLAGS}")
-    set(CMAKE_OBJC_FLAGS "${CMAKE_OBJC_FLAGS} ${IMHEX_COMMON_FLAGS}")
-
     # Only generate minimal debug information for stacktraces in RelWithDebInfo builds
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -g1")
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -g1")
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        # Add flags for debug info in inline functions
-        set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -gstatement-frontiers -ginline-points")
-        set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -gstatement-frontiers -ginline-points")
+    if (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+        if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+            addCCXXFlag("-g1" ${target})
+        endif()
+
+        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+            # Add flags for debug info in inline functions
+            addCCXXFlag("-gstatement-frontiers" ${target})
+            addCCXXFlag("-ginline-points" ${target})
+        endif()
     endif()
 endmacro()
 
@@ -643,12 +761,22 @@ macro(addBundledLibraries)
 
     add_subdirectory(${THIRD_PARTY_LIBS_FOLDER}/microtar EXCLUDE_FROM_ALL)
 
+    set(CLIP_ENABLE_IMAGE OFF CACHE BOOL "")
+    set(CLIP_EXAMPLES OFF CACHE BOOL "")
+    set(CLIP_TESTS OFF CACHE BOOL "")
+    set(CLIP_INSTALL OFF CACHE BOOL "")
+    set(CLIP_X11_WITH_PNG OFF CACHE BOOL "")
+    set(CLIP_SUPPORT_WINXP OFF CACHE BOOL "")
+    add_subdirectory(${THIRD_PARTY_LIBS_FOLDER}/clip EXCLUDE_FROM_ALL)
+    target_include_directories(clip INTERFACE $<BUILD_INTERFACE:${THIRD_PARTY_LIBS_FOLDER}/clip>)
+
     add_subdirectory(${EXTERNAL_LIBS_FOLDER}/libwolv EXCLUDE_FROM_ALL)
 
     set(XDGPP_INCLUDE_DIRS "${THIRD_PARTY_LIBS_FOLDER}/xdgpp")
     set(FPHSA_NAME_MISMATCHED ON CACHE BOOL "")
 
     if(NOT USE_SYSTEM_FMT)
+        set(FMT_INSTALL OFF CACHE BOOL "Disable install targets for libfmt" FORCE)
         add_subdirectory(${THIRD_PARTY_LIBS_FOLDER}/fmt EXCLUDE_FROM_ALL)
         set(FMT_LIBRARIES fmt::fmt-header-only)
     else()
@@ -688,8 +816,8 @@ macro(addBundledLibraries)
         add_subdirectory(${THIRD_PARTY_LIBS_FOLDER}/lunasvg EXCLUDE_FROM_ALL)
         set(LUNASVG_LIBRARIES lunasvg)
     else()
-        find_package(LunaSVG REQUIRED)
-        set(LUNASVG_LIBRARIES lunasvg)
+        find_package(lunasvg REQUIRED)
+        set(LUNASVG_LIBRARIES lunasvg::lunasvg)
     endif()
 
     if (NOT USE_SYSTEM_LLVM)
@@ -711,7 +839,7 @@ macro(addBundledLibraries)
     endif()
 
     if (USE_SYSTEM_BOOST)
-        find_package(Boost REQUIRED)
+        find_package(Boost REQUIRED CONFIG COMPONENTS regex)
         set(BOOST_LIBRARIES Boost::regex)
     else()
         add_subdirectory(${THIRD_PARTY_LIBS_FOLDER}/boost ${CMAKE_CURRENT_BINARY_DIR}/boost EXCLUDE_FROM_ALL)
@@ -721,13 +849,10 @@ macro(addBundledLibraries)
     set(LIBPL_BUILD_CLI_AS_EXECUTABLE OFF CACHE BOOL "" FORCE)
     set(LIBPL_ENABLE_PRECOMPILED_HEADERS ${IMHEX_ENABLE_PRECOMPILED_HEADERS} CACHE BOOL "" FORCE)
 
-    if (WIN32)
-        set(LIBPL_SHARED_LIBRARY ON CACHE BOOL "" FORCE)
-    else()
-        set(LIBPL_SHARED_LIBRARY OFF CACHE BOOL "" FORCE)
-    endif()
+    set(LIBPL_SHARED_LIBRARY OFF CACHE BOOL "" FORCE)
 
     add_subdirectory(${EXTERNAL_LIBS_FOLDER}/pattern_language EXCLUDE_FROM_ALL)
+    add_subdirectory(${EXTERNAL_LIBS_FOLDER}/disassembler EXCLUDE_FROM_ALL)
 
     if (LIBPL_SHARED_LIBRARY)
         install(
@@ -752,30 +877,6 @@ macro(addBundledLibraries)
 
     find_package(mbedTLS 3.4.0 REQUIRED)
     find_package(Magic 5.39 REQUIRED)
-
-    if (NOT IMHEX_DISABLE_STACKTRACE)
-        if (WIN32)
-            message(STATUS "StackWalk enabled!")
-            set(LIBBACKTRACE_LIBRARIES DbgHelp.lib)
-        else ()
-            find_package(Backtrace)
-            if (${Backtrace_FOUND})
-                message(STATUS "Backtrace enabled! Header: ${Backtrace_HEADER}")
-
-                if (Backtrace_HEADER STREQUAL "backtrace.h")
-                    set(LIBBACKTRACE_LIBRARIES ${Backtrace_LIBRARY})
-                    set(LIBBACKTRACE_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR})
-                    add_compile_definitions(BACKTRACE_HEADER=<${Backtrace_HEADER}>)
-                    add_compile_definitions(HEX_HAS_BACKTRACE)
-                elseif (Backtrace_HEADER STREQUAL "execinfo.h")
-                    set(LIBBACKTRACE_LIBRARIES ${Backtrace_LIBRARY})
-                    set(LIBBACKTRACE_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR})
-                    add_compile_definitions(BACKTRACE_HEADER=<${Backtrace_HEADER}>)
-                    add_compile_definitions(HEX_HAS_EXECINFO)
-                endif()
-            endif()
-        endif()
-    endif()
 endmacro()
 
 function(enableUnityBuild TARGET)
@@ -784,71 +885,22 @@ function(enableUnityBuild TARGET)
     endif ()
 endfunction()
 
-function(generatePDBs)
-    if (NOT IMHEX_GENERATE_PDBS)
-        return()
-    endif ()
-
-    if (NOT WIN32 OR CMAKE_BUILD_TYPE STREQUAL "Debug")
-        return()
-    endif ()
-
-    include(FetchContent)
-    FetchContent_Declare(
-            cv2pdb
-            URL "https://github.com/rainers/cv2pdb/releases/download/v0.52/cv2pdb-0.52.zip"
-            DOWNLOAD_EXTRACT_TIMESTAMP ON
-    )
-    FetchContent_Populate(cv2pdb)
-
-    set(PDBS_TO_GENERATE main main-forwarder libimhex ${PLUGINS})
-    foreach (PDB ${PDBS_TO_GENERATE})
-        if (PDB STREQUAL "main")
-            set(GENERATED_PDB imhex)
-        elseif (PDB STREQUAL "main-forwarder")
-            set(GENERATED_PDB imhex-gui)
-        elseif (PDB STREQUAL "libimhex")
-            set(GENERATED_PDB libimhex)
-        else ()
-            set(GENERATED_PDB plugins/${PDB})
-        endif ()
-
-        if (IMHEX_REPLACE_DWARF_WITH_PDB)
-            set(PDB_OUTPUT_PATH ${CMAKE_BINARY_DIR}/${GENERATED_PDB})
-        else ()
-            set(PDB_OUTPUT_PATH)
-        endif()
-
-        add_custom_target(${PDB}_pdb DEPENDS ${CMAKE_BINARY_DIR}/${GENERATED_PDB}.pdb)
-        add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/${GENERATED_PDB}.pdb
-                WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-                COMMAND
-                (
-                    ${CMAKE_COMMAND} -E remove -f ${CMAKE_BINARY_DIR}/${GENERATED_PDB}.pdb &&
-                    ${cv2pdb_SOURCE_DIR}/cv2pdb64.exe $<TARGET_FILE:${PDB}> ${PDB_OUTPUT_PATH} &&
-                    ${CMAKE_COMMAND} -E remove -f ${CMAKE_BINARY_DIR}/${GENERATED_PDB}
-                ) || (exit 0)
-                COMMAND_EXPAND_LISTS)
-
-        install(FILES ${CMAKE_BINARY_DIR}/${GENERATED_PDB}.pdb DESTINATION ".")
-
-        add_dependencies(imhex_all ${PDB}_pdb)
-    endforeach ()
+function(setSDKPaths)
+    if (WIN32)
+        set(SDK_PATH "./sdk" PARENT_SCOPE)
+    elseif (APPLE)
+        set(SDK_PATH "${CMAKE_INSTALL_PREFIX}/${BUNDLE_NAME}/Contents/Resources/sdk" PARENT_SCOPE)
+    else()
+        set(SDK_PATH "share/imhex/sdk" PARENT_SCOPE)
+    endif()
 
+    set(SDK_BUILD_PATH "${CMAKE_BINARY_DIR}/sdk" PARENT_SCOPE)
 endfunction()
 
 function(generateSDKDirectory)
-    if (WIN32)
-        set(SDK_PATH "./sdk")
-    elseif (APPLE)
-        set(SDK_PATH "${CMAKE_INSTALL_PREFIX}/${BUNDLE_NAME}/Contents/Resources/sdk")
-    else()
-        set(SDK_PATH "share/imhex/sdk")
-    endif()
-
-    set(SDK_BUILD_PATH "${CMAKE_BINARY_DIR}/sdk")
-
+    setSDKPaths()
     install(DIRECTORY ${CMAKE_SOURCE_DIR}/lib/libimhex DESTINATION "${SDK_PATH}/lib" PATTERN "**/source/*" EXCLUDE)
+    install(DIRECTORY ${CMAKE_SOURCE_DIR}/lib/trace    DESTINATION "${SDK_PATH}/lib" PATTERN "**/source/*" EXCLUDE)
     install(DIRECTORY ${CMAKE_SOURCE_DIR}/lib/external DESTINATION "${SDK_PATH}/lib")
     install(DIRECTORY ${CMAKE_SOURCE_DIR}/lib/third_party/imgui DESTINATION "${SDK_PATH}/lib/third_party" PATTERN "**/source/*" EXCLUDE)
     if (NOT USE_SYSTEM_FMT)
@@ -865,6 +917,19 @@ function(generateSDKDirectory)
     install(FILES ${CMAKE_SOURCE_DIR}/cmake/build_helpers.cmake DESTINATION "${SDK_PATH}/cmake")
     install(DIRECTORY ${CMAKE_SOURCE_DIR}/cmake/sdk/ DESTINATION "${SDK_PATH}")
     install(TARGETS libimhex ARCHIVE DESTINATION "${SDK_PATH}/lib")
+    install(TARGETS tracing ARCHIVE DESTINATION "${SDK_PATH}/lib")
+
+    install(DIRECTORY ${CMAKE_SOURCE_DIR}/plugins/ui/include DESTINATION "${SDK_PATH}/lib/ui/include")
+    install(FILES ${CMAKE_SOURCE_DIR}/plugins/ui/CMakeLists.txt DESTINATION "${SDK_PATH}/lib/ui/")
+    if (WIN32)
+        install(TARGETS ui ARCHIVE DESTINATION "${SDK_PATH}/lib")
+    endif()
+
+    install(DIRECTORY ${CMAKE_SOURCE_DIR}/plugins/fonts/include DESTINATION "${SDK_PATH}/lib/fonts/include")
+    install(FILES ${CMAKE_SOURCE_DIR}/plugins/fonts/CMakeLists.txt DESTINATION "${SDK_PATH}/lib/fonts/")
+    if (WIN32)
+        install(TARGETS fonts ARCHIVE DESTINATION "${SDK_PATH}/lib")
+    endif()
 endfunction()
 
 function(addIncludesFromLibrary target library)
@@ -885,4 +950,4 @@ function(precompileHeaders target includeFolder)
             PUBLIC
             "$<$<COMPILE_LANGUAGE:CXX>:${INCLUDES}>"
     )
-endfunction()
+endfunction()

cmake/modules/FindmbedTLS.cmake

@@ -40,7 +40,12 @@ IF(MBEDTLS_FOUND)
     STRING(REGEX REPLACE "^lib" "" MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY_FILE})
     STRING(REGEX REPLACE "^lib" "" MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY_FILE})
     STRING(REGEX REPLACE "^lib" "" MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY_FILE})
-    SET(MBEDTLS_LIBRARIES "-L${MBEDTLS_LIBRARY_DIR} -l${MBEDTLS_LIBRARY_FILE} -l${MBEDX509_LIBRARY_FILE} -l${MBEDCRYPTO_LIBRARY_FILE}")
+
+    if (MSVC)
+        SET(MBEDTLS_LIBRARIES ${MBEDTLS_LIBRARY_FILE}.lib ${MBEDX509_LIBRARY_FILE}.lib ${MBEDCRYPTO_LIBRARY_FILE}.lib)
+    else()
+        SET(MBEDTLS_LIBRARIES "-L${MBEDTLS_LIBRARY_DIR} -l${MBEDTLS_LIBRARY_FILE} -l${MBEDX509_LIBRARY_FILE} -l${MBEDCRYPTO_LIBRARY_FILE}")
+    endif()
 
     IF(NOT MBEDTLS_FIND_QUIETLY)
         MESSAGE(STATUS "Found mbedTLS:")

cmake/modules/ImHexPlugin.cmake

@@ -1,4 +1,5 @@
 macro(add_imhex_plugin)
+    setSDKPaths()
     # Parse arguments
     set(options LIBRARY_PLUGIN)
     set(oneValueArgs NAME IMHEX_VERSION)
@@ -28,6 +29,10 @@ macro(add_imhex_plugin)
         endif()
     endif()
 
+    if (IMHEX_PLUGIN_LIBRARY_PLUGIN)
+        install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/" DESTINATION "${SDK_PATH}/lib/plugins/${IMHEX_PLUGIN_NAME}")
+    endif()
+
     # Define new project for plugin
     project(${IMHEX_PLUGIN_NAME})
 
@@ -62,7 +67,11 @@ macro(add_imhex_plugin)
     )
 
     # Set rpath of plugin libraries to the plugins folder
-    if (APPLE)
+    if (WIN32)
+        if (IMHEX_PLUGIN_LIBRARY_PLUGIN)
+            set_target_properties(${IMHEX_PLUGIN_NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
+        endif()
+    elseif (APPLE)
         set_target_properties(${IMHEX_PLUGIN_NAME} PROPERTIES BUILD_RPATH "@executable_path/../Frameworks;@executable_path/plugins")
     endif()
 
@@ -147,4 +156,4 @@ macro (enable_plugin_feature feature)
 
     remove_definitions(-DIMHEX_PLUGIN_${IMHEX_PLUGIN_NAME}_FEATURE_${feature}=0)
     add_definitions(-DIMHEX_PLUGIN_${IMHEX_PLUGIN_NAME}_FEATURE_${feature}=1)
-endmacro()
+endmacro()

cmake/sdk/CMakeLists.txt

@@ -38,25 +38,30 @@ add_subdirectory(lib/external/libwolv EXCLUDE_FROM_ALL)
 set(LIBPL_ENABLE_CLI OFF CACHE BOOL "" FORCE)
 add_subdirectory(lib/external/pattern_language EXCLUDE_FROM_ALL)
 
-find_package(CURL REQUIRED)
-find_package(mbedTLS 3.4.0 REQUIRED)
-set(CURL_LIBRARIES ${CURL_LIBRARIES} PARENT_SCOPE)
-set(MBEDTLS_LIBRARIES ${MBEDTLS_LIBRARIES} PARENT_SCOPE)
-
 add_subdirectory(lib/libimhex)
+add_subdirectory(lib/trace)
 
 if (WIN32)
     set_target_properties(libimhex PROPERTIES
             IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/../libimhex.dll"
             IMPORTED_IMPLIB "${CMAKE_CURRENT_SOURCE_DIR}/lib/liblibimhex.dll.a"
             INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/lib/libimhex/include")
+    set_target_properties(tracing PROPERTIES
+            IMPORTED_IMPLIB "${CMAKE_CURRENT_SOURCE_DIR}/lib/libtracing.a"
+            INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/lib/trace/include")
 elseif (APPLE)
     file(GLOB LIBIMHEX_DYLIB "${CMAKE_CURRENT_SOURCE_DIR}/../../Frameworks/libimhex.*.dylib")
     set_target_properties(libimhex PROPERTIES
             IMPORTED_LOCATION "${LIBIMHEX_DYLIB}"
             INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/lib/libimhex/include")
+    set_target_properties(tracing PROPERTIES
+            IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/../libtracing.a"
+            INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/lib/trace/include")
 else()
     set_target_properties(libimhex PROPERTIES
             IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/../libimhex.so"
             INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/lib/libimhex/include")
+    set_target_properties(tracing PROPERTIES
+            IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/../libtracing.a"
+            INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/lib/trace/include")
 endif()

dist/AppImage/AppImageBuilder.yml

@@ -11,32 +11,23 @@ AppDir:
     exec_args: $@
   apt:
     arch:
-    - amd64
+    - "{{ARCHITECTURE_PACKAGE}}"
     allow_unauthenticated: true
     sources:
-    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ oracular main restricted
-    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ oracular-updates main restricted
-    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ oracular universe
-    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ oracular-updates universe
-    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ oracular multiverse
-    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ oracular-updates multiverse
-    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ oracular-backports main restricted
-        universe multiverse
-    - sourceline: deb http://security.ubuntu.com/ubuntu oracular-security main restricted
-    - sourceline: deb http://security.ubuntu.com/ubuntu oracular-security universe
-    - sourceline: deb http://security.ubuntu.com/ubuntu oracular-security multiverse
+    - sourceline: 'deb [arch=amd64] http://us.archive.ubuntu.com/ubuntu/ oracular main restricted universe multiverse'
+    - sourceline: 'deb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports/ oracular main restricted universe multiverse'
     include:
     - librsvg2-common
-    - libbz2-1.0:amd64
-    - libcap2:amd64
-    - libdbus-1-3:amd64
-    - libfontconfig1:amd64
-    - libgpg-error0:amd64
-    - liblzma5:amd64
-    - libnss-mdns:amd64
-    - libpcre3:amd64
-    - libselinux1:amd64
-    - libtinfo6:amd64
+    - libbz2-1.0
+    - libcap2
+    - libdbus-1-3
+    - libfontconfig1
+    - libgpg-error0
+    - liblzma5
+    - libnss-mdns
+    - libpcre3
+    - libselinux1
+    - libtinfo6
   files:
     include:
     - /lib/x86_64-linux-gnu/libLLVM-13.so.1
@@ -133,6 +124,6 @@ AppDir:
     - usr/share/doc/*/NEWS.*
     - usr/share/doc/*/TODO.*
 AppImage:
-  arch: x86_64
-  update-information: gh-releases-zsync|WerWolv|ImHex|latest|imhex-*-x86_64.AppImage.zsync
-  file_name: imhex-{{VERSION}}-x86_64.AppImage
+  arch: "{{ARCHITECTURE_APPIMAGE_BUILDER}}"
+  update-information: gh-releases-zsync|WerWolv|ImHex|latest|imhex-*-{{ARCHITECTURE_FILE_NAME}}.AppImage.zsync
+  file_name: imhex-{{VERSION}}-{{ARCHITECTURE_FILE_NAME}}.AppImage

dist/AppImage/Dockerfile

@@ -30,8 +30,14 @@ ARG LTO=ON
 ARG BUILD_TYPE=RelWithDebInfo
 ARG GIT_COMMIT_HASH
 ARG GIT_BRANCH
+ARG ARCHITECTURE_PACKAGE
+ARG ARCHITECTURE_FILE_NAME
+ARG ARCHITECTURE_APPIMAGE_BUILDER
 WORKDIR /build
-SHELL ["bash", "-c"] # Ubuntu sh doesnt support string substitution
+
+# Ubuntu sh doesnt support string substitution
+SHELL ["bash", "-c"]
+
 RUN <<EOF
 # Prepare ImHex build
 set -xe
@@ -73,7 +79,10 @@ pip3 install git+https://github.com/AppImageCrafters/appimage-builder@f38699e
 
 # Package ImHex as AppImage
 export VERSION=$(cat /imhex/VERSION)
-appimage-builder --recipe /imhex/dist/AppImageBuilder.yml
+export ARCHITECTURE_PACKAGE=${ARCHITECTURE_PACKAGE}
+export ARCHITECTURE_FILE_NAME=${ARCHITECTURE_FILE_NAME}
+export ARCHITECTURE_APPIMAGE_BUILDER=${ARCHITECTURE_APPIMAGE_BUILDER}
+appimage-builder --recipe /imhex/dist/AppImage/AppImageBuilder.yml
 EOF
 
 FROM scratch

dist/Arch/PKGBUILD

@@ -8,8 +8,8 @@ pkgdesc="A Hex Editor for Reverse Engineers, Programmers and people who value th
 arch=("x86_64")
 url="https://github.com/WerWolv/ImHex"
 license=('GPL2')
-depends=(glfw mbedtls fontconfig freetype2 libglvnd dbus gtk3 curl fmt yara nlohmann-json zlib bzip2 xz zstd)
-makedepends=(git)
+depends=(glfw mbedtls fontconfig freetype2 libglvnd dbus gtk3 curl fmt yara zlib bzip2 xz zstd)
+makedepends=(git nlohmann-json)
 provides=(imhex)
 conflicts=(imhex)
 source=("$url/releases/download/v$pkgver/imhex-$pkgver-ArchLinux-x86_64.pkg.tar.zst")

dist/ImHex-9999.ebuild

@@ -21,7 +21,6 @@ RDEPEND="${DEPEND}
 		media-libs/glfw
 		sys-apps/file
 		net-libs/mbedtls
-		dev-cpp/nlohmann_json
 		sys-apps/dbus
 		sys-apps/xdg-desktop-portal
 		sys-libs/zlib
@@ -30,4 +29,6 @@ RDEPEND="${DEPEND}
 		app-arch/zstd
 		app-arch/lz4
 		"
-BDEPEND="${DEPEND}"
+BDEPEND="${DEPEND}
+		dev-cpp/nlohmann_json
+		"

dist/compiling/linux.md

@@ -9,7 +9,7 @@ On Linux, ImHex is built through regular GCC (or optionally Clang).
 cd ImHex
 mkdir -p build
 cd build
-CC=gcc-12 CXX=g++-12                          \
+CC=gcc-14 CXX=g++-14                          \
 cmake -G "Ninja"                              \
     -DCMAKE_BUILD_TYPE=Release                \
     -DCMAKE_INSTALL_PREFIX="/usr"             \

dist/compiling/macos.md

@@ -3,7 +3,7 @@
 On macOS, ImHex is built through regular GCC and LLVM clang.
 
 1. Clone the repo using `git clone https://github.com/WerWolv/ImHex --recurse-submodules`
-2. Install all the dependencies using `brew bundle --no-lock --file dist/Brewfile`
+2. Install all the dependencies using `brew bundle --no-lock --file dist/macOS/Brewfile`
 3. Build ImHex itself using the following commands:
 ```sh
 cd ImHex
@@ -19,4 +19,4 @@ cmake -G "Ninja"                          \
   -DIMHEX_GENERATE_PACKAGE=ON             \
   ..
 ninja install
-```
+```

dist/gen_release_notes.py

@@ -32,11 +32,17 @@ def main(args: list) -> int:
 
     sorted_commits = {}
     for commit in master_commits:
-        category, commit_name = commit.split(":", 1)
+        if commit == "":
+            continue
 
-        if category not in sorted_commits:
-            sorted_commits[category] = []
-        sorted_commits[category].append(commit_name)
+        try:
+            category, commit_name = commit.split(":", 1)
+
+            if category not in sorted_commits:
+                sorted_commits[category] = []
+            sorted_commits[category].append(commit_name)
+        except:
+            print(f"Failed to parse commit: {commit}")
 
     for category in sorted_commits:
         print(f"## {category}\n")

dist/get_deps_msys2.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env sh
 
-pacman -S --needed --noconfirm pactoys
+pacman -S --needed --noconfirm pactoys unzip
 pacboy -S --needed --noconfirm  \
   gcc:p          \
   lld:p          \

dist/imhex.desktop

@@ -1,4 +1,5 @@
 [Desktop Entry]
+Version=1.0
 Name=ImHex
 Comment=ImHex Hex Editor
 GenericName=Hex Editor
@@ -10,3 +11,8 @@ Categories=Development;IDE;
 StartupWMClass=imhex
 Keywords=static-analysis;reverse-engineering;disassembler;disassembly;hacking;forensics;hex-editor;cybersecurity;security;binary-analysis;
 MimeType=application/vnd.imhex.proj;
+Actions=NewFile;
+
+[Desktop Action NewFile]
+Exec=imhex --new
+Name=Create New File

dist/macOS/arm64.Dockerfile

@@ -1,10 +1,21 @@
 # This base image is also known as "crosscompile". See arm64.crosscompile.Dockerfile
-FROM ghcr.io/itrooz/macos-crosscompile:clang17-nosdk as build
+FROM ghcr.io/itrooz/macos-crosscompile:clang19-nosdk as build
 
 ENV MACOSX_DEPLOYMENT_TARGET 13.0
 
 # -- DOWNLOADING STUFF
 
+# Update vcpkg
+RUN <<EOF
+cp /vcpkg/triplets/community/arm-osx-mytriplet.cmake /tmp/arm-osx-mytriplet.cmake
+git -C /vcpkg clean -ffdx
+git -C /vcpkg checkout origin/master
+git -C /vcpkg reset --hard
+git -C /vcpkg pull
+/vcpkg/bootstrap-vcpkg.sh
+cp /tmp/arm-osx-mytriplet.cmake /vcpkg/triplets/community/arm-osx-mytriplet.cmake
+EOF
+
 ## Install make
 RUN --mount=type=cache,target=/var/lib/apt/lists/ apt update && apt install -y make
 
@@ -35,7 +46,7 @@ EOF
 
 ## Download libmagic
 ### Clone libmagic
-RUN git clone --depth 1 --branch FILE5_45 https://github.com/file/file /mnt/file
+RUN git clone --depth 1 --branch FILE5_46 https://github.com/file/file /mnt/file
 ### Download libmagic dependencies
 RUN --mount=type=cache,target=/var/lib/apt/lists/ apt update && apt install -y libtool autoconf
 

dist/macOS/arm64.crosscompile.Dockerfile

@@ -1,4 +1,4 @@
-# This image is is provided for reference, but a (probably more up to date) image should be available at https://github.com/iTrooz/macos-crosscompile
+# This image is provided for reference, but a (probably more up to date) image should be available at https://github.com/iTrooz/macos-crosscompile
 FROM ubuntu:22.04
 
 ENV PATH                $PATH:/osxcross/target/bin

dist/rpm/imhex.spec

@@ -123,9 +123,10 @@ cp -a lib/third_party/xdgpp/LICENSE                                  %{buildroot
 %doc README.md
 %{_bindir}/imhex
 %{_bindir}/imhex-updater
-%{_datadir}/pixmaps/%{name}.png
+%{_datadir}/pixmaps/%{name}.svg
 %{_datadir}/applications/%{name}.desktop
 %{_datadir}/mime/packages/%{name}.xml
 %{_libdir}/libimhex.so*
 %{_libdir}/%{name}/
+/usr/lib/debug/%{_libdir}/*.debug
 %{_metainfodir}/net.werwolv.%{name}.metainfo.xml

dist/vcpkg.json

@@ -0,0 +1,16 @@
+{
+    "name": "vcpkg",
+    "version": "1.0.0",
+    "builtin-baseline": "7e21420f775f72ae938bdeb5e6068f722088f06a",
+    "dependencies": [
+        "libmagic",
+        "freetype",
+        "mbedtls",
+        "zlib",
+        "bzip2",
+        "liblzma",
+        "zstd",
+        "glfw3",
+        "curl"
+    ]
+}

dist/web/Dockerfile

@@ -1,4 +1,4 @@
-FROM emscripten/emsdk:3.1.51 as build
+FROM emscripten/emsdk:4.0.8 AS build
 
 # Used to invalidate layer cache but not mount cache
 # See https://github.com/moby/moby/issues/41715#issuecomment-733976493
@@ -13,6 +13,7 @@ RUN <<EOF
 set -xe
 
 git clone https://github.com/microsoft/vcpkg /vcpkg
+git -C /vcpkg pull
 /vcpkg/bootstrap-vcpkg.sh
 sed -i 's/vcpkg_install_make(${EXTRA_ARGS})/vcpkg_install_make(${EXTRA_ARGS} SUBPATH src)/g' /vcpkg/ports/libmagic/portfile.cmake
 EOF
@@ -27,7 +28,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
 ' >> /emsdk/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake
 EOF
 
-ENV VCPKG_DEFAULT_BINARY_CACHE /cache/vcpkg
+ENV VCPKG_DEFAULT_BINARY_CACHE=/cache/vcpkg
 RUN --mount=type=cache,target=/cache <<EOF
 # Install dependencies with vcpkg
 set -xe
@@ -45,7 +46,7 @@ EOF
 
 # Build ImHex
 ARG JOBS=4
-ENV CCACHE_DIR /cache/ccache
+ENV CCACHE_DIR=/cache/ccache
 
 RUN mkdir /build
 WORKDIR /build
@@ -67,6 +68,7 @@ cmake /imhex
     -DCMAKE_CXX_COMPILER_LAUNCHER=ccache                                                                \
     -DCMAKE_TOOLCHAIN_FILE=/vcpkg/scripts/buildsystems/vcpkg.cmake                                      \
     -DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=/emsdk/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake \
+    -DLIBROMFS_COMPRESS_RESOURCES=OFF                                                                   \
     -DCMAKE_BUILD_TYPE=Release
 
 ninja -j $JOBS
@@ -79,13 +81,12 @@ EOF
 # See https://stackoverflow.com/questions/41701849/cannot-modify-accept-encoding-with-fetch https://github.com/AnthumChris/fetch-progress-indicators/issues/13
 RUN du -b /build/imhex.wasm | cut -f1 > imhex.wasm.size
 
-FROM scratch as raw
+FROM scratch AS raw
 COPY --from=build [             \
     # ImHex                     \
     "/build/imhex.wasm",        \
     "/build/imhex.wasm.size",   \
     "/build/imhex.js",          \
-    "/build/imhex.worker.js",   \
                                 \
     # Static files              \
     "/build/index.html",        \
@@ -93,7 +94,7 @@ COPY --from=build [             \
     "/build/wasm-config.js",    \
     "/build/enable-threads.js", \
     "/build/favicon.ico",       \
-    "/build/icon.png",          \
+    "/build/icon.svg",          \
     "/build/manifest.json",     \
     "/build/robots.txt",        \
     "/build/sitemap.xml",       \

dist/web/source/icon.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" version="1">
+ <rect style="opacity:0.2" width="55" height="10" x="5" y="-60" rx="1.41" transform="rotate(90)"/>
+ <rect style="fill:#2b50a1" width="55" height="10" x="4" y="-60" rx="1.41" transform="rotate(90)"/>
+ <rect style="fill:#2b50a1" width="55" height="10" x="4" y="-14" rx="1.41" transform="rotate(90)"/>
+ <rect style="fill:#2b50a1" width="55" height="10" x="4" y="-33" rx="1.41" transform="rotate(90)"/>
+ <path style="opacity:0.2" d="M 5.3808594,5 C 4.6158118,5 4,5.6158118 4,6.3808594 V 13.619141 C 4,14.384188 4.6158118,15 5.3808594,15 H 31.619141 C 32.384188,15 33,14.384188 33,13.619141 V 6.3808594 C 33,5.6158118 32.384188,5 31.619141,5 Z M 40.400391,5 C 39.624791,5 39,5.6247906 39,6.4003906 V 13.599609 C 39,14.375209 39.624791,15 40.400391,15 H 58.599609 C 59.375209,15 60,14.375209 60,13.599609 V 6.4003906 C 60,5.6247906 59.375209,5 58.599609,5 Z M 5.3808594,50 C 4.6158118,50 4,50.615812 4,51.380859 v 7.238282 C 4,59.384188 4.6158118,60 5.3808594,60 H 31.619141 C 32.384188,60 33,59.384188 33,58.619141 V 51.380859 C 33,50.615812 32.384188,50 31.619141,50 Z"/>
+ <rect style="fill:#3a6be0" width="29" height="10" x="4" y="4" rx="1.381"/>
+ <rect style="fill:#3a6be0" width="21" height="10" x="39" y="4" rx="1.4"/>
+ <rect style="fill:#3a6be0" width="29" height="10" x="4" y="49" rx="1.381"/>
+ <path style="fill:#ffffff;opacity:0.1" d="M 5.3808594 4 C 4.6158118 4 4 4.6158118 4 5.3808594 L 4 6.3808594 C 4 5.6158118 4.6158118 5 5.3808594 5 L 31.619141 5 C 32.384188 5 33 5.6158118 33 6.3808594 L 33 5.3808594 C 33 4.6158118 32.384188 4 31.619141 4 L 5.3808594 4 z M 40.400391 4 C 39.624791 4 39 4.6247906 39 5.4003906 L 39 6.4003906 C 39 5.6247906 39.624791 5 40.400391 5 L 58.599609 5 C 59.375209 5 60 5.6247906 60 6.4003906 L 60 5.4003906 C 60 4.6247906 59.375209 4 58.599609 4 L 40.400391 4 z M 5.3808594 49 C 4.6158118 49 4 49.615812 4 50.380859 L 4 51.380859 C 4 50.615812 4.6158118 50 5.3808594 50 L 31.619141 50 C 32.384188 50 33 50.615812 33 51.380859 L 33 50.380859 C 33 49.615812 32.384188 49 31.619141 49 L 5.3808594 49 z"/>
+</svg>

dist/web/source/index.html

@@ -11,7 +11,7 @@
     <meta name="title" content="ImHex">
     <meta name="description" content="Free and extremely powerful Online Hex Editor for your Web Browser. ImHex is a free and open source Hex Editor for Reverse Engineers and Developers and Data Analysts.">
     <link rel="icon" type="image/x-icon" href="favicon.ico">
-    <link rel="apple-touch-icon" href="icon.png">
+    <link rel="apple-touch-icon" href="icon.svg">
 
     <!-- Open Graph / Facebook -->
     <meta property="og:type" content="website">
@@ -38,7 +38,7 @@
             "founder": "WerWolv",
             "slogan": "A Hex Editor for Reverse Engineers, Programmers and people who value their retinas when working at 3 AM.",
             "url": "https://imhex.werwolv.net",
-            "logo": "https://imhex.werwolv.net/assets/logos/logo.png"
+            "logo": "https://imhex.werwolv.net/assets/logos/logo.svg"
         }
     </script>
 

dist/web/source/manifest.json

@@ -10,8 +10,8 @@
     ],
     "icons": [
         {
-            "src": "icon.png",
-            "type": "image/png",
+            "src": "icon.svg",
+            "type": "image/svg",
             "sizes": "640x640"
         }
     ],

dist/web/source/sitemap.xml

@@ -57,6 +57,11 @@
     <loc>https://web.imhex.werwolv.net?lang=it-IT</loc>
     <lastmod>2024-01-02T11:44:00+00:00</lastmod>
   </url>
+  <url>
+    <title>Русский</title>
+    <loc>https://web.imhex.werwolv.net?lang=ru-RU</loc>
+    <lastmod>2024-01-02T11:44:00+00:00</lastmod>
+  </url>
 
 
 </urlset>

dist/web/source/wasm-config.js

@@ -9,8 +9,9 @@ fetch("imhex.wasm.size").then(async (resp) => {
 // inspired from: https://github.com/WordPress/wordpress-playground/pull/46 (but had to be modified)
 function monkeyPatch(progressFun) {
     const _instantiateStreaming = WebAssembly.instantiateStreaming;
-    WebAssembly.instantiateStreaming = (response, ...args) => {
+    WebAssembly.instantiateStreaming = async (responsePromise, ...args) => {
         // Do not collect wasm content length here see above
+        let response = await responsePromise
         const file = response.url.substring(
             new URL(response.url).origin.length + 1
         );
@@ -235,12 +236,11 @@ var Module = {
     totalDependencies: 0,
     monitorRunDependencies: function(left) {
     },
-    instantiateWasm: function(imports, successCallback) {
+    instantiateWasm: async function(imports, successCallback) {
         imports.env.glfwSetCursor = glfwSetCursorCustom
         imports.env.glfwCreateStandardCursor = glfwCreateStandardCursorCustom
-        instantiateAsync(wasmBinary, wasmBinaryFile, imports, (result) => {
-            successCallback(result.instance, result.module)
-        });
+        let result = await instantiateAsync(null, findWasmBinary(), imports);
+        successCallback(result.instance, result.module)
     },
     arguments: []
 };

lib/libimhex/CMakeLists.txt

@@ -39,6 +39,10 @@ set(LIBIMHEX_SOURCES
         source/helpers/default_paths.cpp
         source/helpers/imgui_hooks.cpp
         source/helpers/semantic_version.cpp
+        source/helpers/keys.cpp
+        source/helpers/freetype.cpp
+        source/helpers/udp_server.cpp
+        source/helpers/clipboard.cpp
 
         source/test/tests.cpp
 
@@ -50,21 +54,25 @@ set(LIBIMHEX_SOURCES
         source/ui/view.cpp
         source/ui/popup.cpp
         source/ui/toast.cpp
+        source/ui/banner.cpp
 
         source/subcommands/subcommands.cpp
 )
 
 if (APPLE)
-    set(OSX_11_0_SDK_PATH  /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.0.sdk)
+    set(OSX_SDK_PATH  /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX13.sdk)
     if (NOT CMAKE_OSX_SYSROOT)
-        if (IS_DIRECTORY ${OSX_11_0_SDK_PATH})
-            set(CMAKE_OSX_SYSROOT ${OSX_11_0_SDK_PATH})
+        if (IS_DIRECTORY ${OSX_SDK_PATH})
+            set(CMAKE_OSX_SYSROOT ${OSX_SDK_PATH})
         else ()
-            message(WARNING "CMAKE_OSX_SYSROOT not set and macOS 10.9 SDK not found! Using default one.")
+            message(WARNING "CMAKE_OSX_SYSROOT not set and macOS SDK not found! Using default one.")
         endif ()
     endif ()
 
-    set(LIBIMHEX_SOURCES ${LIBIMHEX_SOURCES} source/helpers/utils_macos.m)
+    set(LIBIMHEX_SOURCES ${LIBIMHEX_SOURCES}
+            source/helpers/utils_macos.m
+            source/helpers/macos_menu.m
+    )
 endif ()
 
 if (IMHEX_EXTERNAL_PLUGIN_BUILD)
@@ -77,6 +85,15 @@ else()
         add_library(libimhex SHARED ${LIBIMHEX_SOURCES})
     endif()
 
+    if (IMHEX_ENABLE_CXX_MODULES)
+        target_sources(libimhex
+                PUBLIC
+                FILE_SET cxx_modules TYPE CXX_MODULES
+                FILES
+                include/hex.cppm
+        )
+    endif()
+
     set(LIBIMHEX_LIBRARY_TYPE PUBLIC)
     target_compile_definitions(libimhex PRIVATE IMHEX_PROJECT_NAME="${PROJECT_NAME}")
 endif()
@@ -121,31 +138,40 @@ setupCompilerFlags(libimhex)
 include(GenerateExportHeader)
 generate_export_header(libimhex)
 
-target_include_directories(libimhex ${LIBIMHEX_LIBRARY_TYPE} include ${XDGPP_INCLUDE_DIRS} ${MBEDTLS_INCLUDE_DIR} ${MAGIC_INCLUDE_DIRS} ${LLVM_INCLUDE_DIRS} ${FMT_INCLUDE_DIRS} ${LIBBACKTRACE_INCLUDE_DIRS})
-target_link_directories(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${MBEDTLS_LIBRARY_DIR} ${MAGIC_LIBRARY_DIRS})
-
-if (NOT EMSCRIPTEN)
-    # curl is only used in non-emscripten builds
-    target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} CURL::libcurl)
-endif()
-
+target_include_directories(libimhex ${LIBIMHEX_LIBRARY_TYPE} include ${XDGPP_INCLUDE_DIRS} ${LLVM_INCLUDE_DIRS} ${FMT_INCLUDE_DIRS})
 
 if (NOT IMHEX_EXTERNAL_PLUGIN_BUILD)
     if (WIN32)
         set_target_properties(libimhex PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
-        target_link_options(libimhex PRIVATE -Wl,--export-all-symbols)
+        if (NOT MSVC)
+            target_link_options(libimhex PRIVATE -Wl,--export-all-symbols)
+        endif()
+        target_link_libraries(libimhex PRIVATE Netapi32.lib)
+        target_compile_definitions(libimhex PRIVATE EXPORT_SYMBOLS=1)
     elseif (APPLE)
         find_library(FOUNDATION NAMES Foundation)
         target_link_libraries(libimhex PUBLIC ${FOUNDATION})
     endif ()
 
-    target_link_libraries(libimhex PRIVATE microtar libwolv ${NFD_LIBRARIES} magic dl ${JTHREAD_LIBRARIES})
-    target_link_libraries(libimhex PUBLIC libpl ${IMGUI_LIBRARIES})
+    target_link_libraries(libimhex PRIVATE libpl microtar ${NFD_LIBRARIES} magic)
+    target_link_libraries(libimhex PUBLIC libwolv libpl_includes libpl-gen ${IMGUI_LIBRARIES} ${JTHREAD_LIBRARIES})
+
+    if (NOT WIN32)
+        target_link_libraries(libimhex PRIVATE dl)
+    endif()
+
+    if (NOT EMSCRIPTEN)
+        target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} CURL::libcurl clip)
+    endif()
+
+    target_include_directories(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${MBEDTLS_INCLUDE_DIR} ${LIBBACKTRACE_INCLUDE_DIRS} ${MAGIC_INCLUDE_DIRS})
+    target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${MBEDTLS_LIBRARIES})
+    target_link_directories(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${MBEDTLS_LIBRARY_DIR} ${MAGIC_LIBRARY_DIRS})
 
     precompileHeaders(libimhex "${CMAKE_CURRENT_SOURCE_DIR}/include")
 endif()
 
-target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${NLOHMANN_JSON_LIBRARIES} imgui_all_includes ${MBEDTLS_LIBRARIES} ${FMT_LIBRARIES} ${LUNASVG_LIBRARIES} ${BOOST_LIBRARIES})
+target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${NLOHMANN_JSON_LIBRARIES} imgui_all_includes ${FMT_LIBRARIES} ${LUNASVG_LIBRARIES} ${BOOST_LIBRARIES} tracing)
 
 set_property(TARGET libimhex PROPERTY INTERPROCEDURAL_OPTIMIZATION FALSE)
 

lib/libimhex/include/hex.cppm

@@ -0,0 +1,51 @@
+module;
+
+#include <cmath>
+#include <map>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <exception>
+#include <algorithm>
+#include <locale>
+#include <array>
+#include <filesystem>
+#include <functional>
+#include <memory>
+#include <list>
+#include <atomic>
+#include <ranges>
+#include <fstream>
+#include <thread>
+#include <future>
+
+#include <fmt/format.h>
+#include <nlohmann/json.hpp>
+#include <wolv/io/file.hpp>
+
+#include <imgui.h>
+#include <imgui_internal.h>
+#include <hex/ui/imgui_imhex_extensions.h>
+
+#include <hex/helpers/auto_reset.hpp>
+#include <hex/api/event_manager.hpp>
+#include <hex/providers/provider.hpp>
+#include <hex/providers/provider_data.hpp>
+#include <hex/data_processor/node.hpp>
+#include <hex/data_processor/link.hpp>
+#include <hex/data_processor/attribute.hpp>
+#include <pl/pattern_language.hpp>
+
+export module hex;
+
+#define HEX_MODULE_EXPORT
+#include <hex/api/task_manager.hpp>
+#include <hex/api/achievement_manager.hpp>
+#include <hex/api/imhex_api.hpp>
+#include <hex/api/layout_manager.hpp>
+#include <hex/api/localization_manager.hpp>
+#include <hex/api/plugin_manager.hpp>
+#include <hex/api/shortcut_manager.hpp>
+#include <hex/api/theme_manager.hpp>
+#include <hex/api/tutorial_manager.hpp>
+#include <hex/api/workspace_manager.hpp>

lib/libimhex/include/hex.hpp

@@ -1,3 +1,9 @@
 #pragma once
 
 #include <hex/helpers/types.hpp>
+
+#if defined(HEX_MODULE_EXPORT)
+    #define EXPORT_MODULE export
+#else
+    #define EXPORT_MODULE
+#endif

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

@@ -14,8 +14,9 @@
 #include <imgui.h>
 #include <hex/ui/imgui_imhex_extensions.h>
 #include <hex/api/localization_manager.hpp>
+#include <hex/helpers/auto_reset.hpp>
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     class AchievementManager;
 
@@ -361,7 +362,7 @@ namespace hex {
          * @brief Returns all registered achievements
          * @return All achievements
          */
-        static const std::unordered_map<std::string, std::unordered_map<std::string, std::unique_ptr<Achievement>>>& getAchievements();
+        static const std::unordered_map<UnlocalizedString, std::unordered_map<UnlocalizedString, std::unique_ptr<Achievement>>>& getAchievements();
 
         /**
          * @brief Returns all achievement start nodes
@@ -369,14 +370,14 @@ namespace hex {
          * @param rebuild Whether to rebuild the list of start nodes
          * @return All achievement start nodes
          */
-        static const std::unordered_map<std::string, std::vector<AchievementNode*>>& getAchievementStartNodes(bool rebuild = true);
+        static const std::unordered_map<UnlocalizedString, std::vector<AchievementNode*>>& getAchievementStartNodes(bool rebuild = true);
 
         /**
          * @brief Returns all achievement nodes
          * @param rebuild Whether to rebuild the list of nodes
          * @return All achievement nodes
          */
-        static const std::unordered_map<std::string, std::list<AchievementNode>>& getAchievementNodes(bool rebuild = true);
+        static const std::unordered_map<UnlocalizedString, std::list<AchievementNode>>& getAchievementNodes(bool rebuild = true);
 
         /**
          * @brief Loads the progress of all achievements from the achievements save file
@@ -405,4 +406,4 @@ namespace hex {
         static Achievement& addAchievementImpl(std::unique_ptr<Achievement> &&newAchievement);
     };
 
-}
+}

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

@@ -16,26 +16,31 @@
 #include <nlohmann/json.hpp>
 #include <wolv/io/fs.hpp>
 
-using ImGuiDataType = int;
-using ImGuiInputTextFlags = int;
-struct ImColor;
-enum ImGuiCustomCol : int;
+#if !defined(HEX_MODULE_EXPORT)
+    using ImGuiDataType = int;
+    using ImGuiInputTextFlags = int;
+    struct ImColor;
+    enum ImGuiCustomCol : int;
+    typedef int ImGuiColorEditFlags;
+#endif
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
-    class View;
-    class Task;
+    #if !defined(HEX_MODULE_EXPORT)
+        class View;
+        class Task;
 
-    namespace dp {
-        class Node;
-    }
-    namespace prv {
-        class Provider;
-    }
+        namespace dp {
+            class Node;
+        }
+        namespace prv {
+            class Provider;
+        }
 
-    namespace LocalizationManager {
-        class LanguageDefinition;
-    }
+        namespace LocalizationManager {
+            class LanguageDefinition;
+        }
+    #endif
 
     /*
         The Content Registry is the heart of all features in ImHex that are in some way extendable by Plugins.
@@ -43,7 +48,6 @@ namespace hex {
         plugins when needed.
     */
     namespace ContentRegistry {
-
         /* Settings Registry. Allows adding of new entries into the ImHex preferences window. */
         namespace Settings {
 
@@ -177,7 +181,7 @@ namespace hex {
 
                 class SliderDataSize : public Widget {
                 public:
-                    SliderDataSize(u64 defaultValue, u64 min, u64 max) : m_value(defaultValue), m_min(min), m_max(max) { }
+                    SliderDataSize(u64 defaultValue, u64 min, u64 max, u64 stepSize) : m_value(defaultValue), m_min(min), m_max(max), m_stepSize(stepSize) { }
                     bool draw(const std::string &name) override;
 
                     void load(const nlohmann::json &data) override;
@@ -188,11 +192,12 @@ namespace hex {
                 protected:
                     u64 m_value;
                     u64 m_min, m_max;
+                    u64 m_stepSize;
                 };
 
                 class ColorPicker : public Widget {
                 public:
-                    explicit ColorPicker(ImColor defaultColor);
+                    explicit ColorPicker(ImColor defaultColor, ImGuiColorEditFlags flags = 0);
 
                     bool draw(const std::string &name) override;
 
@@ -202,12 +207,14 @@ namespace hex {
                     [[nodiscard]] ImColor getColor() const;
 
                 protected:
-                    std::array<float, 4> m_value{};
+                    std::array<float, 4> m_value = {}, m_defaultValue = {};
+                    ImGuiColorEditFlags m_flags;
                 };
 
                 class DropDown : public Widget {
                 public:
-                    explicit DropDown(const std::vector<std::string> &items, const std::vector<nlohmann::json> &settingsValues, const nlohmann::json &defaultItem) : m_items(items), m_settingsValues(settingsValues), m_defaultItem(defaultItem) { }
+                    explicit DropDown(const std::vector<std::string> &items, const std::vector<nlohmann::json> &settingsValues, const nlohmann::json &defaultItem) : m_items(items.begin(), items.end()), m_settingsValues(settingsValues), m_defaultItem(defaultItem) { }
+                    explicit DropDown(const std::vector<UnlocalizedString> &items, const std::vector<nlohmann::json> &settingsValues, const nlohmann::json &defaultItem) : m_items(items), m_settingsValues(settingsValues), m_defaultItem(defaultItem) { }
 
                     bool draw(const std::string &name) override;
 
@@ -218,7 +225,7 @@ namespace hex {
                     const nlohmann::json& getValue() const;
 
                 protected:
-                    std::vector<std::string> m_items;
+                    std::vector<UnlocalizedString> m_items;
                     std::vector<nlohmann::json> m_settingsValues;
                     nlohmann::json m_defaultItem;
 
@@ -325,7 +332,7 @@ namespace hex {
                             result = defaultValue;
 
                         return result.get<T>();
-                    } catch (const nlohmann::json::exception &e) {
+                    } catch (const nlohmann::json::exception &) {
                         return defaultValue;
                     }
                 }
@@ -573,7 +580,7 @@ namespace hex {
             namespace impl {
 
                 void add(std::unique_ptr<View> &&view);
-                const std::map<std::string, std::unique_ptr<View>>& getEntries();
+                const std::map<UnlocalizedString, std::unique_ptr<View>>& getEntries();
 
             }
 
@@ -594,6 +601,12 @@ namespace hex {
              * @return The view if it exists, nullptr otherwise
              */
             View* getViewByName(const UnlocalizedString &unlocalizedName);
+
+            /**
+             * @brief Gets the currently focused view
+             * @return The view that is focused right now. nullptr if none is focused
+             */
+            View* getFocusedView();
         }
 
         /* Tools Registry. Allows adding new entries to the tools window */
@@ -623,8 +636,7 @@ namespace hex {
         /* Data Inspector Registry. Allows adding of new types to the data inspector */
         namespace DataInspector {
 
-            enum class NumberDisplayStyle
-            {
+            enum class NumberDisplayStyle : u8 {
                 Decimal,
                 Hexadecimal,
                 Octal
@@ -678,6 +690,13 @@ namespace hex {
                 std::optional<impl::EditingFunction> editingFunction = std::nullopt
             );
 
+            /**
+             * @brief Allows adding new menu items to data inspector row context menus. Call this function inside the
+             * draw function of the data inspector row definition.
+             * @param function Callback that will draw menu items
+             */
+            void drawMenuItems(const std::function<void()> &function);
+
         }
 
         /* Data Processor Node Registry. Allows adding new processor nodes to be used in the data processor */
@@ -712,7 +731,7 @@ namespace hex {
                 add(impl::Entry {
                     unlocalizedCategory,
                     unlocalizedName,
-                    [=, ...args = std::forward<Args>(args)] mutable {
+                    [=, ...args = std::forward<Args>(args)]() mutable {
                         auto node = std::make_unique<T>(std::forward<Args>(args)...);
                         node->setUnlocalizedName(unlocalizedName);
                         return node;
@@ -993,7 +1012,7 @@ namespace hex {
             void add(bool addToList = true) {
                 auto typeName = T().getTypeName();
 
-                impl::add(typeName, [] -> std::unique_ptr<prv::Provider> {
+                impl::add(typeName, []() -> std::unique_ptr<prv::Provider> {
                     return std::make_unique<T>();
                 });
 
@@ -1008,7 +1027,7 @@ namespace hex {
 
             namespace impl {
 
-                using Callback = std::function<std::string(prv::Provider *provider, u64 address, size_t size)>;
+                using Callback = std::function<std::string(prv::Provider *provider, u64 address, size_t size, bool preview)>;
                 struct ExportMenuEntry {
                     UnlocalizedString unlocalizedName;
                     Callback callback;
@@ -1016,7 +1035,7 @@ namespace hex {
 
                 struct FindOccurrence {
                     Region region;
-                    enum class DecodeType { ASCII, Binary, UTF16, Unsigned, Signed, Float, Double } decodeType;
+                    enum class DecodeType { ASCII, UTF8, Binary, UTF16, Unsigned, Signed, Float, Double } decodeType;
                     std::endian endian = std::endian::native;
                     bool selected;
                 };
@@ -1101,9 +1120,9 @@ namespace hex {
 
                 [[nodiscard]] const UnlocalizedString& getUnlocalizedName() const { return m_unlocalizedName; }
 
-            protected:
-                const static int TextInputFlags;
+                [[nodiscard]] static int DefaultTextInputFlags();
 
+            protected:
                 bool drawDefaultScalarEditingTextBox(u64 address, const char *format, ImGuiDataType dataType, u8 *data, ImGuiInputTextFlags flags) const;
                 bool drawDefaultTextEditingTextBox(u64 address, std::string &data, ImGuiInputTextFlags flags) const;
 
@@ -1354,6 +1373,7 @@ namespace hex {
 
         }
 
+        /* Data Information Registry. Allows adding new analyzers to the data information view */
         namespace DataInformation {
 
             class InformationSection {
@@ -1420,6 +1440,54 @@ namespace hex {
 
         }
 
+        /* Disassembler Registry. Allows adding new disassembler architectures */
+        namespace Disassembler {
+
+            struct Instruction {
+                u64 address;
+                u64 offset;
+                size_t size;
+                std::string bytes;
+                std::string mnemonic;
+                std::string operators;
+            };
+
+            class Architecture {
+            public:
+                explicit Architecture(std::string name) : m_name(std::move(name)) {}
+                virtual ~Architecture() = default;
+
+                virtual bool start() = 0;
+                virtual void end() = 0;
+
+                virtual std::optional<Instruction> disassemble(u64 imageBaseAddress, u64 instructionLoadAddress, u64 instructionDataAddress, std::span<const u8> code) = 0;
+                virtual void drawSettings() = 0;
+
+                [[nodiscard]] const std::string& getName() const { return m_name; }
+
+            private:
+                std::string m_name;
+            };
+
+            namespace impl {
+
+                using CreatorFunction = std::function<std::unique_ptr<Architecture>()>;
+
+                void addArchitectureCreator(CreatorFunction function);
+
+                const std::map<std::string, CreatorFunction>& getArchitectures();
+
+            }
+
+            template<std::derived_from<Architecture> T>
+            void add(auto && ...args) {
+                impl::addArchitectureCreator([...args = std::move(args)] {
+                    return std::make_unique<T>(args...);
+                });
+            }
+
+        }
+
     }
 
 }

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

@@ -11,37 +11,47 @@
 
 #include <hex/api/imhex_api.hpp>
 #include <hex/helpers/logger.hpp>
-#include <hex/helpers/patches.hpp>
 
 #include <wolv/types/type_name.hpp>
 
-#define EVENT_DEF_IMPL(event_name, event_name_string, should_log, ...)                                                                                      \
-    struct event_name final : public hex::impl::Event<__VA_ARGS__> {                                                                                        \
-        constexpr static auto Id = [] { return hex::impl::EventId(event_name_string); }();                                                                  \
-        constexpr static auto ShouldLog = (should_log);                                                                                                     \
-        explicit event_name(Callback func) noexcept : Event(std::move(func)) { }                                                                            \
-                                                                                                                                                            \
-        static EventManager::EventList::iterator subscribe(Event::Callback function) { return EventManager::subscribe<event_name>(std::move(function)); }   \
-        static void subscribe(void *token, Event::Callback function) { EventManager::subscribe<event_name>(token, std::move(function)); }                   \
-        static void unsubscribe(const EventManager::EventList::iterator &token) noexcept { EventManager::unsubscribe(token); }                              \
-        static void unsubscribe(void *token) noexcept { EventManager::unsubscribe<event_name>(token); }                                                     \
-        static void post(auto &&...args) { EventManager::post<event_name>(std::forward<decltype(args)>(args)...); }                                         \
+#define EVENT_DEF_IMPL(event_name, event_name_string, should_log, ...)                                                          \
+    struct event_name final : public hex::impl::Event<__VA_ARGS__> {                                                            \
+        constexpr static auto Id = [] { return hex::impl::EventId(event_name_string); }();                                      \
+        constexpr static auto ShouldLog = (should_log);                                                                         \
+        explicit event_name(Callback func) noexcept : Event(std::move(func)) { }                                                \
+                                                                                                                                \
+        static EventManager::EventList::iterator subscribe(Event::Callback function) {                                          \
+            return EventManager::subscribe<event_name>(std::move(function));                                                    \
+        }                                                                                                                       \
+        template<typename = void>                                                                                               \
+        static EventManager::EventList::iterator subscribe(Event::BaseCallback function)                                        \
+        requires (!std::same_as<Event::Callback, Event::BaseCallback>) {                                                        \
+            return EventManager::subscribe<event_name>([function = std::move(function)](auto && ...) { function(); });          \
+        }                                                                                                                       \
+        static void subscribe(void *token, Event::Callback function) {                                                          \
+            EventManager::subscribe<event_name>(token, std::move(function));                                                    \
+        }                                                                                                                       \
+        template<typename = void>                                                                                               \
+        static void subscribe(void *token, Event::BaseCallback function)                                                        \
+        requires (!std::same_as<Event::Callback, Event::BaseCallback>) {                                                        \
+            return EventManager::subscribe<event_name>(token, [function = std::move(function)](auto && ...) { function(); });   \
+        }                                                                                                                       \
+        static void unsubscribe(const EventManager::EventList::iterator &token) noexcept {                                      \
+            EventManager::unsubscribe(token);                                                                                   \
+        }                                                                                                                       \
+        static void unsubscribe(void *token) noexcept {                                                                         \
+            EventManager::unsubscribe<event_name>(token);                                                                       \
+        }                                                                                                                       \
+        static void post(auto &&...args) {                                                                                      \
+            EventManager::post<event_name>(std::forward<decltype(args)>(args)...);                                              \
+        }                                                                                                                       \
     }
 
 #define EVENT_DEF(event_name, ...)          EVENT_DEF_IMPL(event_name, #event_name, true, __VA_ARGS__)
 #define EVENT_DEF_NO_LOG(event_name, ...)   EVENT_DEF_IMPL(event_name, #event_name, false, __VA_ARGS__)
 
 
-/* Forward declarations */
-struct GLFWwindow;
-namespace hex {
-    class Achievement;
-    class View;
-}
-
-namespace pl::ptrn { class Pattern; }
-
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     namespace impl {
 
@@ -75,6 +85,7 @@ namespace hex {
         template<typename... Params>
         struct Event : EventBase {
             using Callback = std::function<void(Params...)>;
+            using BaseCallback = std::function<void()>;
 
             explicit Event(Callback func) noexcept : m_func(std::move(func)) { }
 
@@ -100,7 +111,8 @@ namespace hex {
 
     /**
      * @brief The EventManager allows subscribing to and posting events to different parts of the program.
-     * To create a new event, use the EVENT_DEF macro. This will create a new event type with the given name and parameters
+     * To create a new event, use the EVENT_DEF macro. This will create a new event type with the given name and parameters.
+     * Events should be created in an `events_*.hpp` category file under the `events` folder, and never directly here.
      */
     class EventManager {
     public:
@@ -200,123 +212,4 @@ namespace hex {
         static void unsubscribe(void *token, impl::EventId id);
     };
 
-    /* Default Events */
-    
-    /**
-     * @brief Called when Imhex finished startup, and will enter the main window rendering loop
-     */
-    EVENT_DEF(EventImHexStartupFinished);
-
-    EVENT_DEF(EventFileLoaded, std::fs::path);
-    EVENT_DEF(EventDataChanged, prv::Provider *);
-    EVENT_DEF(EventHighlightingChanged);
-    EVENT_DEF(EventWindowClosing, GLFWwindow *);
-    EVENT_DEF(EventRegionSelected, ImHexApi::HexEditor::ProviderRegion);
-    EVENT_DEF(EventAbnormalTermination, int);
-    EVENT_DEF(EventThemeChanged);
-    EVENT_DEF(EventOSThemeChanged);
-    EVENT_DEF(EventDPIChanged, float, float);
-    EVENT_DEF(EventWindowFocused, bool);
-    EVENT_DEF(EventImHexUpdated, SemanticVersion, SemanticVersion);
-
-    /**
-     * @brief Called when the provider is created.
-     * This event is responsible for (optionally) initializing the provider and calling EventProviderOpened
-     * (although the event can also be called manually without problem)
-     */
-    EVENT_DEF(EventProviderCreated, prv::Provider *);
-    EVENT_DEF(EventProviderChanged, prv::Provider *, prv::Provider *);
-
-    /**
-     * @brief Called as a continuation of EventProviderCreated
-     * this event is normally called immediately after EventProviderCreated successfully initialized the provider.
-     * If no initialization (Provider::skipLoadInterface() has been set), this event should be called manually
-     * If skipLoadInterface failed, this event is not called
-     * 
-     * @note this is not related to Provider::open()
-     */
-    EVENT_DEF(EventProviderOpened,  prv::Provider *);
-    EVENT_DEF(EventProviderClosing, prv::Provider *, bool *);
-    EVENT_DEF(EventProviderClosed,  prv::Provider *);
-    EVENT_DEF(EventProviderDeleted, prv::Provider *);
-    EVENT_DEF(EventProviderSaved,   prv::Provider *);
-    EVENT_DEF(EventWindowInitialized);
-    EVENT_DEF(EventWindowDeinitializing, GLFWwindow *);
-    EVENT_DEF(EventBookmarkCreated, ImHexApi::Bookmarks::Entry&);
-
-    /**
-     * @brief Called upon creation of an IPS patch.
-     * As for now, the event only serves a purpose for the achievement unlock.
-     */
-    EVENT_DEF(EventPatchCreated, const u8*, u64, const PatchKind);
-    EVENT_DEF(EventPatternEvaluating);
-    EVENT_DEF(EventPatternExecuted, const std::string&);
-    EVENT_DEF(EventPatternEditorChanged, const std::string&);
-    EVENT_DEF(EventStoreContentDownloaded, const std::fs::path&);
-    EVENT_DEF(EventStoreContentRemoved, const std::fs::path&);
-    EVENT_DEF(EventImHexClosing);
-    EVENT_DEF(EventAchievementUnlocked, const Achievement&);
-    EVENT_DEF(EventSearchBoxClicked, u32);
-    EVENT_DEF(EventViewOpened, View*);
-    EVENT_DEF(EventFirstLaunch);
-
-    EVENT_DEF(EventFileDragged, bool);
-    EVENT_DEF(EventFileDropped, std::fs::path);
-
-    EVENT_DEF(EventProviderDataModified, prv::Provider *, u64, u64, const u8*);
-    EVENT_DEF(EventProviderDataInserted, prv::Provider *, u64, u64);
-    EVENT_DEF(EventProviderDataRemoved, prv::Provider *, u64, u64);
-    EVENT_DEF(EventProviderDirtied, prv::Provider *);
-
-    /**
-     * @brief Called when a project has been loaded
-     */
-    EVENT_DEF(EventProjectOpened);
-
-    EVENT_DEF_NO_LOG(EventFrameBegin);
-    EVENT_DEF_NO_LOG(EventFrameEnd);
-    EVENT_DEF_NO_LOG(EventSetTaskBarIconState, u32, u32, u32);
-    EVENT_DEF_NO_LOG(EventImGuiElementRendered, ImGuiID, const std::array<float, 4>&);
-
-    EVENT_DEF(RequestAddInitTask, std::string, bool, std::function<bool()>);
-    EVENT_DEF(RequestAddExitTask, std::string, std::function<bool()>);
-    EVENT_DEF(RequestOpenWindow, std::string);
-    EVENT_DEF(RequestHexEditorSelectionChange, Region);
-    EVENT_DEF(RequestPatternEditorSelectionChange, u32, u32);
-    EVENT_DEF(RequestJumpToPattern, const pl::ptrn::Pattern*);
-    EVENT_DEF(RequestAddBookmark, Region, std::string, std::string, color_t, u64*);
-    EVENT_DEF(RequestRemoveBookmark, u64);
-    EVENT_DEF(RequestSetPatternLanguageCode, std::string);
-    EVENT_DEF(RequestRunPatternCode);
-    EVENT_DEF(RequestLoadPatternLanguageFile, std::fs::path);
-    EVENT_DEF(RequestSavePatternLanguageFile, std::fs::path);
-    EVENT_DEF(RequestUpdateWindowTitle);
-    EVENT_DEF(RequestCloseImHex, bool);
-    EVENT_DEF(RequestRestartImHex);
-    EVENT_DEF(RequestOpenFile, std::fs::path);
-    EVENT_DEF(RequestChangeTheme, std::string);
-    EVENT_DEF(RequestOpenPopup, std::string);
-    EVENT_DEF(RequestAddVirtualFile, std::fs::path, std::vector<u8>, Region);
-
-    /**
-     * @brief Creates a provider from it's unlocalized name, and add it to the provider list
-    */
-    EVENT_DEF(RequestCreateProvider, std::string, bool, bool, hex::prv::Provider **);
-    EVENT_DEF(RequestInitThemeHandlers);
-
-    /**
-     * @brief Send an event to the main Imhex instance
-     */
-    EVENT_DEF(SendMessageToMainInstance, const std::string, const std::vector<u8>&);
-
-    /**
-     * Move the data from all PerProvider instances from one provider to another.
-     * The 'from' provider should not have any per provider data after this, and should be immediately deleted
-    */
-    EVENT_DEF(MovePerProviderData, prv::Provider *, prv::Provider *);
-
-    /**
-     * Called when ImHex managed to catch an error in a general try/catch to prevent/recover from a crash
-    */
-    EVENT_DEF(EventCrashRecovered, const std::exception &);
 }

lib/libimhex/include/hex/api/events/events_gui.hpp

@@ -0,0 +1,120 @@
+#pragma once
+
+#include <hex/api/event_manager.hpp>
+
+/* Forward declarations */
+struct GLFWwindow;
+namespace hex { class View; }
+
+/* GUI events definitions */
+namespace hex {
+
+    /**
+     * @brief Signals a newly opened window
+     *
+     * This event is sent when the window has just been opened and docked by the Window manager.
+     *
+     * FIXME: In the event that a newly created window is already docked, this will not be sent.
+     *
+     * FIXME: This is currently only used for the introduction tutorial.
+     *  If the event's only purpose is this, maybe rename it?
+     *
+     * @param view the new view reference
+     */
+    EVENT_DEF(EventViewOpened, View*);
+
+    /**
+     * @brief Signals a change in the DPI scale.
+     *
+     * This event is called once at startup to signal native scale definition (by passing the same value twice).
+     * On Windows OS, this event can also be posted if the window DPI has been changed.
+     *
+     * @param oldScale the old scale
+     * @param newScale the current scale that's now in use
+     */
+    EVENT_DEF(EventDPIChanged, float, float);
+
+    /**
+     * @brief Signals the focus of the ImHex main window.
+     *
+     * This is directly tied as a GLFW window focus callback, and will be called accordingly when GLFW detects
+     * a change in focus.
+     *
+     * @param isFocused true if the window is focused
+     */
+    EVENT_DEF(EventWindowFocused, bool);
+
+    /**
+     * @brief Signals a window being closed.
+     *
+     * Allows reactive clean up of running tasks, and prevents ImHex from closing
+     * by displaying an exit confirmation popup.
+     *
+     * @param window The window reference
+     */
+    EVENT_DEF(EventWindowClosing, GLFWwindow*);
+
+    /**
+     * @brief Informs that the main window is initialized
+     *
+     * On Windows OS, it is used to initialize system theme, if ImHex's theme is following it.
+     *
+     * FIXME: Change event name to reflect Theme detection, if it's only used for that purpose?
+     */
+    EVENT_DEF(EventWindowInitialized);
+
+    /**
+     * @brief Informs that the main window is deinitializing
+     *
+     * Allows for lifecycle cleanup before ImHex shutdown.
+     *
+     * @param window The window reference
+     */
+    EVENT_DEF(EventWindowDeinitializing, GLFWwindow*);
+
+    /**
+     * @brief Signals a theme change in the host OS
+     *
+     * Allows ImHex to react to OS theme changes dynamically during execution.
+     */
+    EVENT_DEF(EventOSThemeChanged);
+
+}
+
+/* silent (no-logging) GUI events definitions */
+namespace hex {
+
+    /**
+     * @brief Signals the start of a new ImGui frame
+     */
+    EVENT_DEF_NO_LOG(EventFrameBegin);
+
+    /**
+     * @brief Signals the end of an ImGui frame
+     */
+    EVENT_DEF_NO_LOG(EventFrameEnd);
+
+    /**
+     * @brief Windows OS: Sets the taskbar icon state
+     *
+     * This event is used on Windows OS to display progress through the taskbar icon (the famous "green loading bar"
+     * in the taskbar).
+     *
+     * @param progressState the progress state (converted from the TaskProgressState enum)
+     * @param progressType the type of progress (converted from the TaskProgressType enum)
+     * @param percentage actual progress percentage (expected from 0 to 100)
+     *
+     * @see hex::ImHexApi::System::TaskProgressState
+     * @see hex::ImHexApi::System::TaskProgressType
+     */
+    EVENT_DEF_NO_LOG(EventSetTaskBarIconState, u32, u32, u32);
+
+    /**
+     * @brief Informs of an ImGui element being rendered
+     *
+     * @param elementId the element's ID
+     * @param boundingBox the bounding box (composed of 4 floats)
+     */
+    EVENT_DEF_NO_LOG(EventImGuiElementRendered, ImGuiID, const std::array<float, 4>&);
+
+}

lib/libimhex/include/hex/api/events/events_interaction.hpp

@@ -0,0 +1,158 @@
+#pragma once
+
+#include <hex/api/event_manager.hpp>
+#include <hex/helpers/patches.hpp>
+
+/* Forward declarations */
+namespace hex { class Achievement; }
+
+/* Interaction events definitions */
+namespace hex {
+
+    /**
+     * @brief Signals a file was loaded
+     *
+     * FIXME: this event is unused and should be scrapped.
+     *
+     * @param path the loaded file's path
+     */
+    EVENT_DEF(EventFileLoaded, std::fs::path);
+
+    /**
+     * @brief Signals a change in the current data
+     *
+     * Enables provider reaction to data change, especially the data inspector.
+     *
+     * This is caused by the following:
+     * - an explicit provider reload, requested by the user (Ctrl+R)
+     * - any user action that results in the creation of an "undo" stack action (generally a data modification)
+     *
+     * @param provider the Provider subject to the data change
+     */
+    EVENT_DEF(EventDataChanged, prv::Provider *);
+
+    /**
+     * @brief Signals a change in highlighting
+     *
+     * The event's only purpose is for the Hex editor to clear highlights when receiving this event.
+     */
+    EVENT_DEF(EventHighlightingChanged);
+
+    /**
+     * @brief Informs of a provider region being selected
+     *
+     * This is very generally used to signal user actions that select a specific region within the provider.
+     * It is also used to pass on regions when the provider changes.
+     *
+     * @param providerRegion the provider-aware region being selected
+     */
+    EVENT_DEF(EventRegionSelected, ImHexApi::HexEditor::ProviderRegion);
+
+    /**
+     * @brief Signals a theme change
+     *
+     * On Windows OS, this is used to reflect the theme color onto the window frame.
+     */
+    EVENT_DEF(EventThemeChanged);
+
+    /**
+     * @brief Signals that a bookmark was created
+     *
+     * For now, this event's only purpose is to unlock an achievement.
+     *
+     * @param entry the new bookmark
+     */
+    EVENT_DEF(EventBookmarkCreated, ImHexApi::Bookmarks::Entry&);
+
+    /**
+     * @brief Called upon creation of an IPS patch.
+     * As for now, the event only serves a purpose for the achievement unlock.
+     *
+     * @param data the pointer to the patch content's start
+     * @param size the patch data size
+     * @param kind the patch's kind
+     */
+    EVENT_DEF(EventPatchCreated, const u8*, u64, const PatchKind);
+
+    /**
+     * @brief Signals the beginning of evaluation of the current pattern
+     *
+     * This allows resetting the drawer view for the pattern data while we wait for the execution completion.
+     */
+    EVENT_DEF(EventPatternEvaluating);
+
+    /**
+     * @brief Signals the completion of the pattern evaluation
+     *
+     * This causes another reset in the drawer view, to refresh the table displayed to the user.
+     *
+     * @param code the execution's status code
+     */
+    EVENT_DEF(EventPatternExecuted, const std::string&);
+
+    /**
+     * @brief Denotes when pattern editor has changed
+     *
+     * FIXME: this event is unused and should be scrapped.
+     */
+    EVENT_DEF(EventPatternEditorChanged, const std::string&);
+
+    /**
+     * @brief Signals that a Content Store item was downloaded
+     *
+     * FIXME: this event is unused and should be scrapped.
+     *
+     * @param path the item's path on the filesystem
+     */
+    EVENT_DEF(EventStoreContentDownloaded, const std::fs::path&);
+
+    /**
+     * @brief Signals the removal of a Content Store item
+     *
+     * Note: at the time of the event firing, the item has already been removed from the filesystem.
+     *
+     * FIXME: this event is unused and should be scrapped.
+     *
+     * @param path the item's old file path where it used to be in the filesystem
+     */
+    EVENT_DEF(EventStoreContentRemoved, const std::fs::path&);
+
+    /**
+     * @brief Signals the unlocking of an achievement
+     *
+     * This is used by the achievement manager to refresh the achievement display, as well as store progress to
+     * the appropriate storage file.
+     *
+     * @param achievement the achievement that was unlocked
+     */
+    EVENT_DEF(EventAchievementUnlocked, const Achievement&);
+
+    /**
+     * @brief Signals a click on the search box
+     *
+     * As there are different behaviours depending on the click (left or right) done by the user,
+     * this allows the consequences of said click to be registered in their own components.
+     *
+     * @param button the ImGuiMouseButton's value
+     */
+    EVENT_DEF(EventSearchBoxClicked, u32);
+
+    /**
+     * @brief Updates on whether a file is being dragged into ImHex
+     *
+     * Allows ImGUi to display a file dragging information on screen when a file is being dragged.
+     *
+     * @param isFileDragged true if a file is being dragged
+     */
+    EVENT_DEF(EventFileDragged, bool);
+
+    /**
+     * @brief Triggers loading when a file is dropped
+     *
+     * The event fires when a file is dropped into ImHex, which passes it to file handlers to load it.
+     *
+     * @param path the dropped file's path
+     */
+    EVENT_DEF(EventFileDropped, std::fs::path);
+
+}

lib/libimhex/include/hex/api/events/events_lifecycle.hpp

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <hex/api/event_manager.hpp>
+
+/* Lifecycle events definitions */
+namespace hex {
+
+    /**
+     * @brief Called when Imhex finished startup, and will enter the main window rendering loop
+     */
+    EVENT_DEF(EventImHexStartupFinished);
+
+    /**
+     * @brief Called when ImHex is closing, to trigger the last shutdown hooks
+     *
+     * This is the last event to fire before complete graceful shutdown.
+     */
+    EVENT_DEF(EventImHexClosing);
+
+    /**
+     * @brief Signals that it's ImHex first launch ever
+     *
+     * This event allows for the launch of the ImHex tutorial (also called Out of Box experience).
+     */
+    EVENT_DEF(EventFirstLaunch);
+
+    /**
+     * FIXME: this event is unused and should be scrapped.
+     */
+    EVENT_DEF(EventAnySettingChanged);
+
+    /**
+     * @brief Ensures correct plugin cleanup on crash
+     *
+     * This event is fired when catching an unexpected error that cannot be recovered and
+     * which forces Imhex to close immediately.
+     *
+     * Subscribing to this event ensures that the plugin can correctly clean up any mission-critical tasks
+     * before forceful shutdown.
+     *
+     * @param signal the POSIX signal code
+     */
+    EVENT_DEF(EventAbnormalTermination, int);
+
+    /**
+     * @brief Informs of the ImHex versions (and difference, if any)
+     *
+     * Called on every startup to inform subscribers of the two versions picked up:
+     * - the version of the previous launch, gathered from the settings file
+     * - the current version, gathered directly from C++ code
+     *
+     * In most cases, and unless ImHex was updated, the two parameters will be the same.
+     *
+     * FIXME: Maybe rename the event to signal a startup information, instead of the misleading
+     *  title that the event could be fired when ImHex detects that it was updated since last launch?
+     *
+     * @param previousLaunchVersion ImHex's version during the previous launch
+     * @param currentVersion ImHex's current version for this startup
+     */
+    EVENT_DEF(EventImHexUpdated, SemanticVersion, SemanticVersion);
+
+    /**
+     * @brief Called when ImHex managed to catch an error in a general try/catch to prevent/recover from a crash
+    */
+    EVENT_DEF(EventCrashRecovered, const std::exception &);
+
+    /**
+     * @brief Called when a project has been loaded
+     */
+    EVENT_DEF(EventProjectOpened);
+
+    /**
+     * @brief Called when a native message was received from another ImHex instance
+     * @param rawData Raw bytes received from other instance
+     */
+    EVENT_DEF(EventNativeMessageReceived, std::vector<u8>);
+
+}

lib/libimhex/include/hex/api/events/events_provider.hpp

@@ -0,0 +1,113 @@
+#pragma once
+
+#include <hex.hpp>
+#include <hex/api/event_manager.hpp>
+
+/* Provider events definitions */
+namespace hex {
+    /**
+     * @brief Called when the provider is created.
+     * This event is responsible for (optionally) initializing the provider and calling EventProviderOpened
+     * (although the event can also be called manually without problem)
+     */
+    EVENT_DEF(EventProviderCreated, prv::Provider *);
+
+    /**
+     * @brief Called as a continuation of EventProviderCreated
+     * this event is normally called immediately after EventProviderCreated successfully initialized the provider.
+     * If no initialization (Provider::skipLoadInterface() has been set), this event should be called manually
+     * If skipLoadInterface failed, this event is not called
+     *
+     * @note this is not related to Provider::open()
+     */
+    EVENT_DEF(EventProviderOpened,  prv::Provider *);
+
+    /**
+     * @brief Signals a change in provider (in-place)
+     *
+     * Note: if the provider was deleted, the new ("current") provider will be `nullptr`
+     *
+     * @param oldProvider the old provider
+     * @param currentProvider the current provider
+     */
+    EVENT_DEF(EventProviderChanged, prv::Provider *, prv::Provider *);
+
+    /**
+     * @brief Signals that a provider was saved
+     *
+     * @param provider the saved provider
+     */
+    EVENT_DEF(EventProviderSaved,   prv::Provider *);
+
+    /**
+     * @brief Signals a provider is closing
+     *
+     * FIXME: as for now, this behaves as a request more than an event. Also, the boolean is always set to true,
+     *  and serves no purpose. This should be moved into the Provider requests section and declared accordingly.
+     *
+     * @param provider the closing provider
+     * @param shouldClose whether the provider should close
+     */
+    EVENT_DEF(EventProviderClosing, prv::Provider *, bool *);
+
+    /**
+     * @brief Signals that a provider was closed
+     *
+     * As this is a closure information broadcast, the provider should generally not be accessed, as it could
+     * result in problems.
+     *
+     * @param provider the now-closed provider
+     */
+    EVENT_DEF(EventProviderClosed,  prv::Provider *);
+
+    /**
+     * @brief Signals that a provider is being deleted
+     *
+     * Provider's data should not be accessed.
+     *
+     * @param provider the provider
+     */
+    EVENT_DEF(EventProviderDeleted, prv::Provider *);
+
+}
+
+/* Provider data events definitions */
+namespace hex {
+
+    /**
+     * @brief Signals the dirtying of a provider
+     *
+     * Any data modification that occurs in a provider dirties it, until its state is either saved or restored.
+     * This event signals that fact to subscribers so additional code can be executed for certain cases.
+     */
+    EVENT_DEF(EventProviderDirtied, prv::Provider *);
+
+    /**
+     * @brief Signals an insertion of new data into a provider
+     *
+     * @param provider the provider
+     * @param offset the start of the insertion
+     * @param size the new data's size
+     */
+    EVENT_DEF(EventProviderDataInserted, prv::Provider *, u64, u64);
+
+    /**
+     * @brief Signals a modification in the provider's data
+     *
+     * @param provider the provider
+     * @param offset the data modification's offset (start address)
+     * @param size the buffer's size
+     * @param buffer the modified data written at this address
+     */
+    EVENT_DEF(EventProviderDataModified, prv::Provider *, u64, u64, const u8*);
+
+    /**
+     * @brief Signals a removal of some of the provider's data
+     *
+     * @param provider the provider
+     * @param offset the deletion offset (start address)
+     * @param size the deleted data's size
+     */
+    EVENT_DEF(EventProviderDataRemoved, prv::Provider *, u64, u64);
+
+}

lib/libimhex/include/hex/api/events/requests_gui.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <hex/api/event_manager.hpp>
+
+/* GUI requests definitions */
+namespace hex {
+
+    /**
+     * @brief Requests the opening of a new window.
+     *
+     * @param name the window's name
+     */
+    EVENT_DEF(RequestOpenWindow, std::string);
+
+    /**
+     * @brief Centralized request to update ImHex's main window title
+     *
+     * This request can be called to make ImHex refresh its main window title, taking into account a new project
+     * or file opened/closed.
+     */
+    EVENT_DEF(RequestUpdateWindowTitle);
+
+    /**
+     * @brief Requests a theme type (light or dark) change
+     *
+     * @param themeType either `Light` or `Dark`
+     */
+    EVENT_DEF(RequestChangeTheme, std::string);
+
+    /**
+     * @brief Requests the opening of a popup
+     *
+     * @param name the popup's name
+     */
+    EVENT_DEF(RequestOpenPopup, std::string);
+
+}

lib/libimhex/include/hex/api/events/requests_interaction.hpp

@@ -0,0 +1,116 @@
+#pragma once
+
+#include <hex.hpp>
+#include <hex/api/event_manager.hpp>
+
+/* Forward declarations */
+namespace pl::ptrn { class Pattern; }
+
+/* Interaction requests definitions */
+namespace hex {
+
+    /**
+     * @brief Requests a selection change in the Hex editor
+     *
+     * This request is handled by the Hex editor, which proceeds to check if the selection is valid.
+     * If it is invalid, the Hex editor fires the `EventRegionSelected` event with nullptr region info.
+     *
+     * @param region the region that should be selected
+     */
+    EVENT_DEF(RequestHexEditorSelectionChange, ImHexApi::HexEditor::ProviderRegion);
+
+    /**
+     * @brief Requests the Pattern editor to move selection
+     *
+     * Requests the Pattern editor to move the cursor's position to reflect the user's click or movement.
+     *
+     * @param line the target line
+     * @param column the target column
+     */
+    EVENT_DEF(RequestPatternEditorSelectionChange, u32, u32);
+
+    /**
+     * @brief Requests a jump to a given pattern
+     *
+     * This request is fired by the Hex editor when the user asks to jump to the pattern.
+     * It is then caught and reflected by the Pattern data component.
+     *
+     * @param pattern the pattern to jump to
+     */
+    EVENT_DEF(RequestJumpToPattern, const pl::ptrn::Pattern*);
+
+    /**
+     * @brief Requests to add a bookmark
+     *
+     * @param region the region to be bookmarked
+     * @param name the bookmark's name
+     * @param comment a comment
+     * @param color the color
+     * @param id the bookmark's unique ID
+     */
+    EVENT_DEF(RequestAddBookmark, Region, std::string, std::string, color_t, u64*);
+
+    /**
+     * @brief Requests a bookmark removal
+     *
+     * @param id the bookmark's unique ID
+     */
+    EVENT_DEF(RequestRemoveBookmark, u64);
+
+    /**
+     * @brief Request the Pattern editor to set its code
+     *
+     * This request allows the rest of ImHex to interface with the Pattern editor component, by setting its code.
+     * This allows for `.hexpat` file loading, and more.
+     *
+     * @param code the code's string
+     */
+    EVENT_DEF(RequestSetPatternLanguageCode, std::string);
+
+    /**
+     * @brief Requests the Pattern editor to run the current code
+     *
+     * This is only ever used in the introduction tutorial.
+     *
+     * FIXME: the name is misleading, as for now this activates the pattern's auto-evaluation rather than a
+     *  one-off execution
+     */
+    EVENT_DEF(RequestRunPatternCode);
+
+    /**
+     * @brief Request to load a pattern language file
+     *
+     * FIXME: this request is unused, as now another component is responsible for pattern file loading.
+     *  This request should be scrapped.
+     *
+     * @param path the pattern file's path
+     */
+    EVENT_DEF(RequestLoadPatternLanguageFile, std::fs::path);
+
+    /**
+     * @brief Request to save a pattern language file
+     *
+     * FIXME: this request is unused, as now another component is responsible for pattern file saving.
+     *  This request should be scrapped.
+     *
+     * @param path the pattern file's path
+     */
+    EVENT_DEF(RequestSavePatternLanguageFile, std::fs::path);
+
+    /**
+     * @brief Requests ImHex to open and process a file
+     *
+     * @param path the file's path
+     */
+    EVENT_DEF(RequestOpenFile, std::fs::path);
+
+    /**
+     * @brief Adds a virtual file in the Pattern editor
+     *
+     * @param path the file's path
+     * @param data the file's data
+     * @param region the impacted region
+     */
+    EVENT_DEF(RequestAddVirtualFile, std::fs::path, std::vector<u8>, Region);
+
+}

lib/libimhex/include/hex/api/events/requests_lifecycle.hpp

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <hex.hpp>
+#include <hex/api/event_manager.hpp>
+
+/* Lifecycle requests definitions */
+namespace hex {
+
+    /**
+     * @brief Emit a request to add an initialization task to the list
+     *
+     * These tasks will be executed at startup.
+     *
+     * @param name Name of the init task
+     * @param isAsync Whether the task is asynchronous (true if yes)
+     * @param callbackFunction The function to call to execute the task
+     */
+    EVENT_DEF(RequestAddInitTask, std::string, bool, std::function<bool()>);
+
+    /**
+     * @brief Emit a request to add an exit task to the list
+     *
+     * These tasks will be executed during the exit phase.
+     *
+     * FIXME: request is unused and should be scrapped.
+     *
+     * @param name Name of the exit task
+     * @param callbackFunction The function to call to execute the task
+     */
+    EVENT_DEF(RequestAddExitTask, std::string, std::function<bool()>);
+
+    /**
+     * @brief Requests ImHex's graceful shutdown
+     *
+     * If there are no questions (bool set to true), ImHex closes immediately.
+     * If set to false, there is a procedure run to prompt a confirmation to the user.
+     *
+     * @param noQuestions true if no questions
+     */
+    EVENT_DEF(RequestCloseImHex, bool);
+
+    /**
+     * @brief Requests ImHex's restart
+     *
+     * This event is necessary for ImHex to restart in the main loop for native and web platforms,
+     * as ImHex cannot simply close and re-open.
+     *
+     * This event serves no purpose on Linux, Windows and macOS platforms.
+     */
+    EVENT_DEF(RequestRestartImHex);
+
+    /**
+     * @brief Requests the initialization of theme handlers
+     *
+     * This is called during ImGui bootstrapping, and should not be called at any other time.
+     */
+    EVENT_DEF(RequestInitThemeHandlers);
+
+    /**
+     * @brief Requests version and first-startup checks
+     *
+     * This request is called during ImHex's startup, and allows ImHex to check if it was updated since last launch.
+     * It also ensures newcomers (that open ImHex for the first time) are greeted with the tutorial.
+     *
+     * FIXME: the name is misleading, as this request does not effectively start any migration. It only executes
+     *  checks about ImHex's version. The name should be changed to reflect this behaviour.
+     */
+    EVENT_DEF(RequestStartMigration);
+
+    /**
+     * @brief Send a subcommand to the main Imhex instance
+     *
+     * This request is called to send a subcommand to the main ImHex instance.
+     * This subcommand will then be executed by a handler when ImHex finishing initializing
+     * (`EventImHexStartupFinished`).
+     *
+     * FIXME: change the name so that it is prefixed with "Request" like every other request.
+     *
+     * @param name the subcommand's name
+     * @param data the subcommand's data
+     */
+    EVENT_DEF(SendMessageToMainInstance, const std::string, const std::vector<u8>&);
+
+}

lib/libimhex/include/hex/api/events/requests_provider.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <hex/api/event_manager.hpp>
+
+/* Provider requests definitions */
+namespace hex {
+
+    /**
+     * @brief Creates a provider from its unlocalized name, and add it to the provider list
+    */
+    EVENT_DEF(RequestCreateProvider, std::string, bool, bool, hex::prv::Provider **);
+
+    /**
+     * @brief Move the data from all PerProvider instances from one provider to another
+     *
+     * The 'from' provider should not have any per provider data after this, and should be immediately deleted
+     *
+     * FIXME: rename with the "Request" prefix to apply standard naming convention.
+    */
+    EVENT_DEF(MovePerProviderData, prv::Provider *, prv::Provider *);
+
+}

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

@@ -3,6 +3,8 @@
 #include <hex.hpp>
 #include <hex/api/localization_manager.hpp>
 #include <hex/helpers/semantic_version.hpp>
+#include <hex/helpers/utils.hpp>
+#include <hex/helpers/fs.hpp>
 
 #include <functional>
 #include <optional>
@@ -11,24 +13,28 @@
 #include <vector>
 #include <map>
 #include <set>
+#include <memory>
+#include "imgui_internal.h"
 
-#include <wolv/io/fs.hpp>
-
-using ImGuiID = unsigned int;
-struct ImVec2;
-struct ImFontAtlas;
-struct ImFont;
+#if !defined(HEX_MODULE_EXPORT)
+    using ImGuiID = unsigned int;
+    struct ImVec2;
+    struct ImFontAtlas;
+    struct ImFont;
+#endif
 struct GLFWwindow;
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
-    namespace impl {
-        class AutoResetBase;
-    }
+    #if !defined(HEX_MODULE_EXPORT)
+        namespace impl {
+            class AutoResetBase;
+        }
 
-    namespace prv {
-        class Provider;
-    }
+        namespace prv {
+            class Provider;
+        }
+    #endif
 
     namespace ImHexApi {
 
@@ -444,6 +450,8 @@ namespace hex {
                 bool isWindowResizable();
 
                 void addAutoResetObject(hex::impl::AutoResetBase *object);
+                void removeAutoResetObject(hex::impl::AutoResetBase *object);
+
                 void cleanup();
 
             }
@@ -493,6 +501,7 @@ namespace hex {
              */
             float getNativeScale();
 
+            float getBackingScaleFactor();
 
             /**
              * @brief Gets the current main window position
@@ -581,6 +590,14 @@ namespace hex {
              */
             const std::string& getGLRenderer();
 
+            /**
+             * @brief Checks if ImHex is being run in a "Corporate Environment"
+             * This function simply checks for common telltale signs such as if the machine is joined a
+             * domain. It's not super accurate, but it's still useful for statistics
+             * @return True if it is
+             */
+            bool isCorporateEnvironment();
+
             /**
              * @brief Checks if ImHex is running in portable mode
              * @return Whether ImHex is running in portable mode
@@ -737,6 +754,7 @@ namespace hex {
                 std::vector<GlyphRange> glyphRanges;
                 Offset offset;
                 u32 flags;
+                std::optional<bool> scalable;
                 std::optional<u32> defaultSize;
             };
 
@@ -744,11 +762,8 @@ namespace hex {
 
                 const std::vector<Font>& getFonts();
 
-                void setCustomFontPath(const std::fs::path &path);
-                void setFontSize(float size);
-                void setFontAtlas(ImFontAtlas *fontAtlas);
+                std::map<UnlocalizedString, ImFont*>& getFontDefinitions();
 
-                void setFonts(ImFont *bold, ImFont *italic);
             }
 
             GlyphRange glyph(const char *glyph);
@@ -756,31 +771,17 @@ namespace hex {
             GlyphRange range(const char *glyphBegin, const char *glyphEnd);
             GlyphRange range(u32 codepointBegin, u32 codepointEnd);
 
-            void loadFont(const std::fs::path &path, const std::vector<GlyphRange> &glyphRanges = {}, Offset offset = {}, u32 flags = 0, std::optional<u32> defaultSize = std::nullopt);
-            void loadFont(const std::string &name, const std::span<const u8> &data, const std::vector<GlyphRange> &glyphRanges = {}, Offset offset = {}, u32 flags = 0, std::optional<u32> defaultSize = std::nullopt);
+            void loadFont(const std::fs::path &path, const std::vector<GlyphRange> &glyphRanges = {}, Offset offset = {}, u32 flags = 0, std::optional<bool> scalable = std::nullopt, std::optional<u32> defaultSize = std::nullopt);
+            void loadFont(const std::string &name, const std::span<const u8> &data, const std::vector<GlyphRange> &glyphRanges = {}, Offset offset = {}, u32 flags = 0, std::optional<bool> scalable = std::nullopt, std::optional<u32> defaultSize = std::nullopt);
 
-            constexpr static float DefaultFontSize = 13.0;
+            constexpr float DefaultFontSize = 13.0;
 
-            ImFont* Bold();
-            ImFont* Italic();
+            void registerFont(const UnlocalizedString &fontName);
+            ImFont* getFont(const UnlocalizedString &fontName);
 
-            /**
-             * @brief Gets the current custom font path
-             * @return The current custom font path
-             */
-            const std::filesystem::path& getCustomFontPath();
-
-            /**
-             * @brief Gets the current font size
-             * @return The current font size
-             */
-            float getFontSize();
-
-            /**
-             * @brief Gets the current font atlas
-             * @return Current font atlas
-             */
-            ImFontAtlas* getFontAtlas();
+            float getDpi();
+            float pixelsToPoints(float pixels);
+            float pointsToPixels(float points);
 
         }
 

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

@@ -4,9 +4,11 @@
 
 #include <string>
 
-struct ImGuiTextBuffer;
+#if !defined(HEX_MODULE_EXPORT)
+    struct ImGuiTextBuffer;
+#endif
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     class LayoutManager {
     public:

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

@@ -10,7 +10,7 @@
 #include <fmt/core.h>
 #include <wolv/types/static_string.hpp>
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     namespace LocalizationManager {
 
@@ -31,7 +31,7 @@ namespace hex {
 
         }
 
-        void loadLanguage(const std::string &language);
+        void loadLanguage(std::string language);
         std::string getLocalizedString(const std::string &unlocalizedString, const std::string &language = "");
 
         [[nodiscard]] const std::map<std::string, std::string> &getSupportedLanguages();
@@ -101,10 +101,9 @@ namespace hex {
     public:
         UnlocalizedString() = default;
 
-        template<typename T>
-        UnlocalizedString(T &&arg) : m_unlocalizedString(std::forward<T>(arg)) {
-            static_assert(!std::same_as<std::remove_cvref_t<T>, Lang>, "Expected a unlocalized name, got a localized one!");
-        }
+        UnlocalizedString(const std::string &string) : m_unlocalizedString(string) { }
+        UnlocalizedString(const char *string) : m_unlocalizedString(string) { }
+        UnlocalizedString(const Lang& arg) = delete;
 
         [[nodiscard]] operator std::string() const {
             return m_unlocalizedString;
@@ -149,3 +148,10 @@ namespace hex {
     }
 
 }
+
+template<>
+struct std::hash<hex::UnlocalizedString> {
+    std::size_t operator()(const hex::UnlocalizedString &string) const noexcept {
+        return std::hash<std::string>{}(string.get());
+    }
+};

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

@@ -10,16 +10,24 @@
 #include <hex/helpers/logger.hpp>
 #include <hex/helpers/auto_reset.hpp>
 
-struct ImGuiContext;
+#if !defined(HEX_MODULE_EXPORT)
+    struct ImGuiContext;
+#endif
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     struct SubCommand {
+        enum class Type : u8 {
+            Option,
+            SubCommand
+        };
+
         std::string commandLong;
         std::string commandShort;
 
         std::string commandDescription;
         std::function<void(const std::vector<std::string>&)> callback;
+        Type type = Type::Option;
     };
 
     struct Feature {

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

@@ -9,7 +9,7 @@
  * that want to store any data to a Project File.
  *
  */
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     namespace prv {
         class Provider;

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

@@ -2,137 +2,27 @@
 
 #include <hex.hpp>
 #include <hex/api/localization_manager.hpp>
+#include <hex/helpers/keys.hpp>
 
 #include <functional>
-#include <memory>
 #include <optional>
 #include <set>
 #include <string>
 
-#include <GLFW/glfw3.h>
+#if !defined(HEX_MODULE_EXPORT)
+    struct ImGuiWindow;
+#endif
 
-struct ImGuiWindow;
+struct KeyEquivalent {
+    bool valid;
+    bool ctrl, opt, cmd, shift;
+    int key;
+};
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     class View;
 
-    enum class Keys : u32 {
-        Space          = GLFW_KEY_SPACE,
-        Apostrophe     = GLFW_KEY_APOSTROPHE,
-        Comma          = GLFW_KEY_COMMA,
-        Minus          = GLFW_KEY_MINUS,
-        Period         = GLFW_KEY_PERIOD,
-        Slash          = GLFW_KEY_SLASH,
-        Num0           = GLFW_KEY_0,
-        Num1           = GLFW_KEY_1,
-        Num2           = GLFW_KEY_2,
-        Num3           = GLFW_KEY_3,
-        Num4           = GLFW_KEY_4,
-        Num5           = GLFW_KEY_5,
-        Num6           = GLFW_KEY_6,
-        Num7           = GLFW_KEY_7,
-        Num8           = GLFW_KEY_8,
-        Num9           = GLFW_KEY_9,
-        Semicolon      = GLFW_KEY_SEMICOLON,
-        Equals         = GLFW_KEY_EQUAL,
-        A              = GLFW_KEY_A,
-        B              = GLFW_KEY_B,
-        C              = GLFW_KEY_C,
-        D              = GLFW_KEY_D,
-        E              = GLFW_KEY_E,
-        F              = GLFW_KEY_F,
-        G              = GLFW_KEY_G,
-        H              = GLFW_KEY_H,
-        I              = GLFW_KEY_I,
-        J              = GLFW_KEY_J,
-        K              = GLFW_KEY_K,
-        L              = GLFW_KEY_L,
-        M              = GLFW_KEY_M,
-        N              = GLFW_KEY_N,
-        O              = GLFW_KEY_O,
-        P              = GLFW_KEY_P,
-        Q              = GLFW_KEY_Q,
-        R              = GLFW_KEY_R,
-        S              = GLFW_KEY_S,
-        T              = GLFW_KEY_T,
-        U              = GLFW_KEY_U,
-        V              = GLFW_KEY_V,
-        W              = GLFW_KEY_W,
-        X              = GLFW_KEY_X,
-        Y              = GLFW_KEY_Y,
-        Z              = GLFW_KEY_Z,
-        LeftBracket    = GLFW_KEY_LEFT_BRACKET,
-        Backslash      = GLFW_KEY_BACKSLASH,
-        RightBracket   = GLFW_KEY_RIGHT_BRACKET,
-        GraveAccent    = GLFW_KEY_GRAVE_ACCENT,
-        World1         = GLFW_KEY_WORLD_1,
-        World2         = GLFW_KEY_WORLD_2,
-        Escape         = GLFW_KEY_ESCAPE,
-        Enter          = GLFW_KEY_ENTER,
-        Tab            = GLFW_KEY_TAB,
-        Backspace      = GLFW_KEY_BACKSPACE,
-        Insert         = GLFW_KEY_INSERT,
-        Delete         = GLFW_KEY_DELETE,
-        Right          = GLFW_KEY_RIGHT,
-        Left           = GLFW_KEY_LEFT,
-        Down           = GLFW_KEY_DOWN,
-        Up             = GLFW_KEY_UP,
-        PageUp         = GLFW_KEY_PAGE_UP,
-        PageDown       = GLFW_KEY_PAGE_DOWN,
-        Home           = GLFW_KEY_HOME,
-        End            = GLFW_KEY_END,
-        CapsLock       = GLFW_KEY_CAPS_LOCK,
-        ScrollLock     = GLFW_KEY_SCROLL_LOCK,
-        NumLock        = GLFW_KEY_NUM_LOCK,
-        PrintScreen    = GLFW_KEY_PRINT_SCREEN,
-        Pause          = GLFW_KEY_PAUSE,
-        F1             = GLFW_KEY_F1,
-        F2             = GLFW_KEY_F2,
-        F3             = GLFW_KEY_F3,
-        F4             = GLFW_KEY_F4,
-        F5             = GLFW_KEY_F5,
-        F6             = GLFW_KEY_F6,
-        F7             = GLFW_KEY_F7,
-        F8             = GLFW_KEY_F8,
-        F9             = GLFW_KEY_F9,
-        F10            = GLFW_KEY_F10,
-        F11            = GLFW_KEY_F11,
-        F12            = GLFW_KEY_F12,
-        F13            = GLFW_KEY_F13,
-        F14            = GLFW_KEY_F14,
-        F15            = GLFW_KEY_F15,
-        F16            = GLFW_KEY_F16,
-        F17            = GLFW_KEY_F17,
-        F18            = GLFW_KEY_F18,
-        F19            = GLFW_KEY_F19,
-        F20            = GLFW_KEY_F20,
-        F21            = GLFW_KEY_F21,
-        F22            = GLFW_KEY_F22,
-        F23            = GLFW_KEY_F23,
-        F24            = GLFW_KEY_F24,
-        F25            = GLFW_KEY_F25,
-        KeyPad0        = GLFW_KEY_KP_0,
-        KeyPad1        = GLFW_KEY_KP_1,
-        KeyPad2        = GLFW_KEY_KP_2,
-        KeyPad3        = GLFW_KEY_KP_3,
-        KeyPad4        = GLFW_KEY_KP_4,
-        KeyPad5        = GLFW_KEY_KP_5,
-        KeyPad6        = GLFW_KEY_KP_6,
-        KeyPad7        = GLFW_KEY_KP_7,
-        KeyPad8        = GLFW_KEY_KP_8,
-        KeyPad9        = GLFW_KEY_KP_9,
-        KeyPadDecimal  = GLFW_KEY_KP_DECIMAL,
-        KeyPadDivide   = GLFW_KEY_KP_DIVIDE,
-        KeyPadMultiply = GLFW_KEY_KP_MULTIPLY,
-        KeyPadSubtract = GLFW_KEY_KP_SUBTRACT,
-        KeyPadAdd      = GLFW_KEY_KP_ADD,
-        KeyPadEnter    = GLFW_KEY_KP_ENTER,
-        KeyPadEqual    = GLFW_KEY_KP_EQUAL,
-        Menu           = GLFW_KEY_MENU,
-    };
-
-
     class Key {
     public:
         constexpr Key() = default;
@@ -175,6 +65,7 @@ namespace hex {
 
         bool isLocal() const;
         std::string toString() const;
+        KeyEquivalent toKeyEquivalent() const;
         const std::set<Key>& getKeys() const;
         bool has(Key key) const;
         bool matches(const Shortcut &other) const;
@@ -194,10 +85,12 @@ namespace hex {
     class ShortcutManager {
     public:
         using Callback = std::function<void()>;
+        using EnabledCallback = std::function<bool()>;
         struct ShortcutEntry {
             Shortcut shortcut;
             std::vector<UnlocalizedString> unlocalizedName;
             Callback callback;
+            EnabledCallback enabledCallback;
         };
 
         /**
@@ -205,9 +98,10 @@ namespace hex {
          * @param shortcut The shortcut to add.
          * @param unlocalizedName The unlocalized name of the shortcut
          * @param callback The callback to call when the shortcut is triggered.
+         * @param enabledCallback Callback that's called to check if this shortcut is enabled
          */
-        static void addGlobalShortcut(const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const Callback &callback);
-        static void addGlobalShortcut(const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const Callback &callback);
+        static void addGlobalShortcut(const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const Callback &callback, const EnabledCallback &enabledCallback = []{ return true; });
+        static void addGlobalShortcut(const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const Callback &callback, const EnabledCallback &enabledCallback = []{ return true; });
 
         /**
          * @brief Add a view-specific shortcut. View-specific shortcuts can only be triggered when the specified view is focused.
@@ -215,9 +109,10 @@ namespace hex {
          * @param shortcut The shortcut to add.
          * @param unlocalizedName The unlocalized name of the shortcut
          * @param callback The callback to call when the shortcut is triggered.
+         * @param enabledCallback Callback that's called to check if this shortcut is enabled
          */
-        static void addShortcut(View *view, const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const Callback &callback);
-        static void addShortcut(View *view, const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const Callback &callback);
+        static void addShortcut(View *view, const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const Callback &callback, const EnabledCallback &enabledCallback = []{ return true; });
+        static void addShortcut(View *view, const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const Callback &callback, const EnabledCallback &enabledCallback = []{ return true; });
 
 
         /**
@@ -242,6 +137,14 @@ namespace hex {
          */
         static void processGlobals(bool ctrl, bool alt, bool shift, bool super, u32 keyCode);
 
+        /**
+         * @brief Runs the callback of a shortcut as if it was pressed on the keyboard
+         * @param shortcut Shortcut to run
+         * @param view View the shortcut belongs to or nullptr to run a global shortcut
+         * @return True if a callback was executed, false if not
+         */
+        static bool runShortcut(const Shortcut &shortcut, const View *view = nullptr);
+
         /**
          * @brief Clear all shortcuts
          */
@@ -252,6 +155,9 @@ namespace hex {
 
         static void enableMacOSMode();
 
+        [[nodiscard]] static std::optional<UnlocalizedString> getLastActivatedMenu();
+        static void resetLastActivatedMenu();
+
         [[nodiscard]] static std::optional<Shortcut> getPreviousShortcut();
 
         [[nodiscard]] static std::vector<ShortcutEntry> getGlobalShortcuts();

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

@@ -11,7 +11,7 @@
 #include <condition_variable>
 #include <source_location>
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     class TaskHolder;
     class TaskManager;
@@ -22,7 +22,7 @@ namespace hex {
     class Task {
     public:
         Task() = default;
-        Task(const UnlocalizedString &unlocalizedName, u64 maxValue, bool background, std::function<void(Task &)> function);
+        Task(const UnlocalizedString &unlocalizedName, u64 maxValue, bool background, bool blocking, std::function<void(Task &)> function);
 
         Task(const Task&) = delete;
         Task(Task &&other) noexcept;
@@ -57,6 +57,7 @@ namespace hex {
         void setInterruptCallback(std::function<void()> callback);
 
         [[nodiscard]] bool isBackgroundTask() const;
+        [[nodiscard]] bool isBlocking() const;
         [[nodiscard]] bool isFinished() const;
         [[nodiscard]] bool hadException() const;
         [[nodiscard]] bool wasInterrupted() const;
@@ -84,6 +85,7 @@ namespace hex {
 
         std::atomic<bool> m_shouldInterrupt = false;
         std::atomic<bool> m_background = true;
+        std::atomic<bool> m_blocking = false;
 
         std::atomic<bool> m_interrupted = false;
         std::atomic<bool> m_finished = false;
@@ -162,6 +164,24 @@ namespace hex {
          */
         static TaskHolder createBackgroundTask(const UnlocalizedString &unlocalizedName, std::function<void()> function);
 
+        /**
+         * @brief Creates a new asynchronous task that shows a blocking modal window
+         * @param unlocalizedName Name of the task
+         * @param maxValue Maximum value of the task
+         * @param function Function to be executed
+         * @return A TaskHolder holding a weak reference to the task
+         */
+        static TaskHolder createBlockingTask(const UnlocalizedString &unlocalizedName, u64 maxValue, std::function<void(Task &)> function);
+
+        /**
+        * @brief Creates a new asynchronous task that shows a blocking modal window
+        * @param unlocalizedName Name of the task
+        * @param maxValue Maximum value of the task
+        * @param function Function to be executed
+        * @return A TaskHolder holding a weak reference to the task
+        */
+        static TaskHolder createBlockingTask(const UnlocalizedString &unlocalizedName, u64 maxValue, std::function<void()> function);
+
         /**
          * @brief Creates a new synchronous task that will execute the given function at the start of the next frame
          * @param function Function to be executed
@@ -202,12 +222,13 @@ namespace hex {
 
         static size_t getRunningTaskCount();
         static size_t getRunningBackgroundTaskCount();
+        static size_t getRunningBlockingTaskCount();
 
         static const std::list<std::shared_ptr<Task>>& getRunningTasks();
         static void runDeferredCalls();
 
     private:
-        static TaskHolder createTask(const UnlocalizedString &unlocalizedName, u64 maxValue, bool background, std::function<void(Task &)> function);
+        static TaskHolder createTask(const UnlocalizedString &unlocalizedName, u64 maxValue, bool background, bool blocking, std::function<void(Task &)> function);
     };
 
 }

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

@@ -9,7 +9,7 @@
 #include <nlohmann/json_fwd.hpp>
 #include <imgui.h>
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     /**
      * @brief The Theme Manager takes care of loading and applying themes
@@ -67,6 +67,7 @@ namespace hex {
 
         static void reset();
 
+        static void setAccentColor(const ImColor &color);
 
     public:
         struct ThemeHandler {
@@ -82,6 +83,7 @@ namespace hex {
         static const std::map<std::string, ThemeHandler>& getThemeHandlers();
         static const std::map<std::string, StyleHandler>& getStyleHandlers();
 
+
     private:
         ThemeManager() = default;
     };

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

@@ -10,7 +10,7 @@
 
 #include <hex/ui/imgui_imhex_extensions.h>
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     class TutorialManager {
     public:
@@ -151,6 +151,9 @@ namespace hex {
         static void addInteractiveHelpText(std::initializer_list<std::variant<Lang, std::string, int>> &&ids, UnlocalizedString unlocalizedString);
         static void addInteractiveHelpLink(std::initializer_list<std::variant<Lang, std::string, int>> &&ids, std::string link);
 
+        static void setLastItemInteractiveHelpPopup(std::function<void()> callback);
+        static void setLastItemInteractiveHelpLink(std::string link);
+
 
         /**
          * @brief Draws the tutorial

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

@@ -6,7 +6,7 @@
 #include <map>
 #include <string>
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     class WorkspaceManager {
     public:
@@ -24,8 +24,8 @@ namespace hex {
 
         static void removeWorkspace(const std::string &name);
 
-        static const auto& getWorkspaces() { return *s_workspaces; }
-        static const auto& getCurrentWorkspace() { return s_currentWorkspace; }
+        static const std::map<std::string, Workspace>& getWorkspaces();
+        static const std::map<std::string, Workspace>::iterator& getCurrentWorkspace();
 
         static void reset();
         static void reload();
@@ -34,9 +34,6 @@ namespace hex {
 
     private:
         WorkspaceManager() = default;
-
-        static AutoReset<std::map<std::string, Workspace>> s_workspaces;
-        static decltype(s_workspaces)::Type::iterator s_currentWorkspace, s_previousWorkspace, s_workspaceToRemove;
     };
 
 }

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

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <hex/api/event_manager.hpp>
 #include <hex/api/imhex_api.hpp>
 
 namespace hex {
@@ -24,6 +23,20 @@ namespace hex {
             ImHexApi::System::impl::addAutoResetObject(this);
         }
 
+        AutoReset(const T &value) : AutoReset() {
+            m_value = value;
+            m_valid = true;
+        }
+
+        AutoReset(T &&value) noexcept : AutoReset() {
+            m_value = std::move(value);
+            m_valid = true;
+        }
+
+        ~AutoReset() {
+            ImHexApi::System::impl::removeAutoResetObject(this);
+        }
+
         T* operator->() {
             return &m_value;
         }

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

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <hex.hpp>
+#include <span>
+#include <string>
+#include <vector>
+
+namespace hex::clipboard {
+
+    void init();
+    void setBinaryData(std::span<const u8> data);
+    [[nodiscard]] std::vector<u8> getBinaryData();
+    void setTextData(const std::string &string);
+    [[nodiscard]] std::string getTextData();
+
+}

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

@@ -44,4 +44,7 @@ namespace hex::dbg {
         }
     }
 
+    bool debugModeEnabled();
+    void setDebugModeEnabled(bool enabled);
+
 }

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

@@ -2,6 +2,7 @@
 
 #include <hex/helpers/fs.hpp>
 
+#include <array>
 #include <vector>
 
 namespace hex::paths {
@@ -82,8 +83,9 @@ namespace hex::paths {
     const static inline impl::DataPath Nodes("scripts/nodes");
     const static inline impl::DataPath Layouts("layouts");
     const static inline impl::DataPath Workspaces("workspaces");
+    const static inline impl::DataPath Disassemblers("disassemblers");
 
-    constexpr static inline std::array<const impl::DefaultPath*, 20> All = {
+    constexpr static inline std::array<const impl::DefaultPath*, 21> All = {
         &Config,
         &Recent,
 
@@ -106,6 +108,7 @@ namespace hex::paths {
         &Nodes,
         &Layouts,
         &Workspaces,
+        &Disassemblers
     };
 
 }

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

@@ -3,6 +3,7 @@
 #include <string_view>
 #include <fmt/core.h>
 #include <fmt/ranges.h>
+#include <fmt/ostream.h>
 
 namespace hex {
 

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

@@ -0,0 +1,60 @@
+#pragma once
+#include "imgui.h"
+#include <vector>
+
+namespace hex::ft {
+
+    class Bitmap {
+        ImU32 m_width;
+        ImU32 m_height;
+        ImU32 m_pitch;
+        std::vector <ImU8> m_data;
+    public:
+        Bitmap(ImU32 width, ImU32 height, ImU32 pitch, ImU8 *data) : m_width(width), m_height(height), m_pitch(pitch), m_data(std::vector<ImU8>(data, data + pitch * height)) {}
+
+        Bitmap(ImU32 width, ImU32 height, ImU32 pitch) : m_width(width), m_height(height), m_pitch(pitch) { m_data.resize(pitch * height); }
+
+        void clear() { m_data.clear(); }
+
+        ImU32 getWidth() const { return m_width; }
+
+        ImU32 getHeight() const { return m_height; }
+
+        ImU32 getPitch() const { return m_pitch; }
+
+        const std::vector <ImU8> &getData() const { return m_data; }
+
+        ImU8 *getData() { return m_data.data(); }
+
+        void lcdFilter();
+    };
+
+    class RGBA {
+    public:
+
+        static ImU32 addAlpha(ImU8 r, ImU8 g, ImU8 b) {
+            color.rgbaVec[0] = r;
+            color.rgbaVec[1] = g;
+            color.rgbaVec[2] = b;
+            color.rgbaVec[3] = (r + g + b) / 3;//luminance
+            return color.rgba;
+        }
+
+        RGBA(ImU8 r, ImU8 g, ImU8 b, ImU8 a) {
+            color.rgbaVec[0] = r;
+            color.rgbaVec[1] = b;
+            color.rgbaVec[2] = g;
+            color.rgbaVec[3] = a;
+        }
+
+        explicit RGBA(ImU32 rgba) {
+            color.rgba = rgba;
+        }
+
+        union RGBAU {
+            ImU8 rgbaVec[4];
+            ImU32 rgba;
+        };
+        inline static RGBAU color;
+    };
+}

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <hex.hpp>
 #include <string>
 #include <vector>
 #include <filesystem>
@@ -7,7 +8,7 @@
 
 #include <wolv/io/fs.hpp>
 
-namespace hex::fs {
+EXPORT_MODULE namespace hex::fs {
 
     enum class DialogMode {
         Open,

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

@@ -12,10 +12,6 @@
 
 #if defined(OS_WEB)
     #include <emscripten/fetch.h>
-
-    using curl_off_t = long;
-#else
-    #include <curl/curl.h>
 #endif
 
 typedef void CURL;
@@ -121,18 +117,18 @@ namespace hex {
 
         static std::string urlDecode(const std::string &input);
 
-    protected:
-        void setDefaultConfig();
+        void setProgress(float progress) { m_progress = progress; }
+        bool isCanceled() const { return m_canceled; }
+
+        static size_t writeToVector(void *contents, size_t size, size_t nmemb, void *userdata);
+        static size_t writeToFile(void *contents, size_t size, size_t nmemb, void *userdata);
 
         template<typename T>
         Result<T> executeImpl(std::vector<u8> &data);
 
-        static size_t writeToVector(void *contents, size_t size, size_t nmemb, void *userdata);
-        static size_t writeToFile(void *contents, size_t size, size_t nmemb, void *userdata);
-        static int progressCallback(void *contents, curl_off_t dlTotal, curl_off_t dlNow, curl_off_t ulTotal, curl_off_t ulNow);
-
     private:
         static void checkProxyErrors();
+        void setDefaultConfig();
 
     private:
         #if defined(OS_WEB)

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

@@ -4,8 +4,7 @@
 
     #include <string>
     #include <future>
-
-    #include <curl/curl.h>
+    #include <mutex>
 
     #include <hex/helpers/logger.hpp>
     #include <hex/helpers/fmt.hpp>
@@ -14,14 +13,26 @@
 
     namespace hex {
 
+        namespace impl {
+
+            void setWriteFunctions(CURL *curl, wolv::io::File &file);
+            void setWriteFunctions(CURL *curl, std::vector<u8> &data);
+            void setupFileUpload(CURL *curl, wolv::io::File &file, const std::string &fileName, const std::string &mimeName);
+            void setupFileUpload(CURL *curl, const std::vector<u8> &data, const std::fs::path &fileName, const std::string &mimeName);
+            int executeCurl(CURL *curl, const std::string &url, const std::string &method, const std::string &body, std::map<std::string, std::string> &headers);
+            long getStatusCode(CURL *curl);
+            std::string getStatusText(int result);
+
+        }
+
+
         template<typename T>
         std::future<HttpRequest::Result<T>> HttpRequest::downloadFile(const std::fs::path &path) {
             return std::async(std::launch::async, [this, path] {
                 std::vector<u8> response;
 
                 wolv::io::File file(path, wolv::io::File::Mode::Create);
-                curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, writeToFile);
-                curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, &file);
+                impl::setWriteFunctions(m_curl, file);
 
                 return this->executeImpl<T>(response);
             });
@@ -31,40 +42,12 @@
         std::future<HttpRequest::Result<T>> HttpRequest::uploadFile(const std::fs::path &path, const std::string &mimeName) {
             return std::async(std::launch::async, [this, path, mimeName]{
                 auto fileName = wolv::util::toUTF8String(path.filename());
-
-                curl_mime *mime     = curl_mime_init(m_curl);
-                curl_mimepart *part = curl_mime_addpart(mime);
-
                 wolv::io::File file(path, wolv::io::File::Mode::Read);
 
-                curl_mime_data_cb(part, file.getSize(),
-                                    [](char *buffer, size_t size, size_t nitems, void *arg) -> size_t {
-                                        auto handle = static_cast<FILE*>(arg);
-
-                                        return fread(buffer, size, nitems, handle);
-                                    },
-                                    [](void *arg, curl_off_t offset, int origin) -> int {
-                                        auto handle = static_cast<FILE*>(arg);
-
-                                        if (fseek(handle, offset, origin) != 0)
-                                            return CURL_SEEKFUNC_CANTSEEK;
-                                        else
-                                            return CURL_SEEKFUNC_OK;
-                                    },
-                                    [](void *arg) {
-                                        auto handle = static_cast<FILE*>(arg);
-
-                                        fclose(handle);
-                                    },
-                                    file.getHandle());
-                curl_mime_filename(part, fileName.c_str());
-                curl_mime_name(part, mimeName.c_str());
-
-                curl_easy_setopt(m_curl, CURLOPT_MIMEPOST, mime);
+                impl::setupFileUpload(m_curl, file, fileName, mimeName);
 
                 std::vector<u8> responseData;
-                curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, writeToVector);
-                curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, &responseData);
+                impl::setWriteFunctions(m_curl, responseData);
 
                 return this->executeImpl<T>(responseData);
             });
@@ -73,19 +56,10 @@
         template<typename T>
         std::future<HttpRequest::Result<T>> HttpRequest::uploadFile(std::vector<u8> data, const std::string &mimeName, const std::fs::path &fileName) {
             return std::async(std::launch::async, [this, data = std::move(data), mimeName, fileName]{
-                curl_mime *mime     = curl_mime_init(m_curl);
-                curl_mimepart *part = curl_mime_addpart(mime);
-
-                curl_mime_data(part, reinterpret_cast<const char *>(data.data()), data.size());
-                auto fileNameStr = wolv::util::toUTF8String(fileName.filename());
-                curl_mime_filename(part, fileNameStr.c_str());
-                curl_mime_name(part, mimeName.c_str());
-
-                curl_easy_setopt(m_curl, CURLOPT_MIMEPOST, mime);
+                impl::setupFileUpload(m_curl, data, fileName, mimeName);
 
                 std::vector<u8> responseData;
-                curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, writeToVector);
-                curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, &responseData);
+                impl::setWriteFunctions(m_curl, responseData);
 
                 return this->executeImpl<T>(responseData);
             });
@@ -96,8 +70,7 @@
             return std::async(std::launch::async, [this] {
 
                 std::vector<u8> responseData;
-                curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, writeToVector);
-                curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, &responseData);
+                impl::setWriteFunctions(m_curl, responseData);
 
                 return this->executeImpl<T>(responseData);
             });
@@ -105,43 +78,16 @@
 
         template<typename T>
         HttpRequest::Result<T> HttpRequest::executeImpl(std::vector<u8> &data) {
-            curl_easy_setopt(m_curl, CURLOPT_URL, m_url.c_str());
-            curl_easy_setopt(m_curl, CURLOPT_CUSTOMREQUEST, m_method.c_str());
-
             setDefaultConfig();
 
-            if (!m_body.empty()) {
-                curl_easy_setopt(m_curl, CURLOPT_POSTFIELDS, m_body.c_str());
+            std::scoped_lock lock(m_transmissionMutex);
+
+            if (auto result = impl::executeCurl(m_curl, m_url, m_method, m_body, m_headers); result != 0) {
+                log::error("Http request '{0} {1}' failed with error {2}: '{3}'", m_method, m_url, u32(result), impl::getStatusText(result));
+                checkProxyErrors();
             }
 
-            curl_slist *headers = nullptr;
-            headers = curl_slist_append(headers, "Cache-Control: no-cache");
-            ON_SCOPE_EXIT { curl_slist_free_all(headers); };
-
-            for (auto &[key, value] : m_headers) {
-                std::string header = hex::format("{}: {}", key, value);
-                headers = curl_slist_append(headers, header.c_str());
-            }
-            curl_easy_setopt(m_curl, CURLOPT_HTTPHEADER, headers);
-
-            {
-                std::scoped_lock lock(m_transmissionMutex);
-
-                auto result = curl_easy_perform(m_curl);
-                if (result != CURLE_OK){
-                    char *url = nullptr;
-                    curl_easy_getinfo(m_curl, CURLINFO_EFFECTIVE_URL, &url);
-                    log::error("Http request '{0} {1}' failed with error {2}: '{3}'", m_method, url, u32(result), curl_easy_strerror(result));
-                    checkProxyErrors();
-
-                    return { };
-                }
-            }
-
-            long statusCode = 0;
-            curl_easy_getinfo(m_curl, CURLINFO_RESPONSE_CODE, &statusCode);
-
-            return Result<T>(statusCode, { data.begin(), data.end() });
+            return Result<T>(impl::getStatusCode(m_curl), { data.begin(), data.end() });
         }
 
     }

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

@@ -0,0 +1,124 @@
+#pragma once
+
+#if defined(__cplusplus)
+enum class Keys {
+#else
+enum Keys {
+#endif
+    Invalid,
+    Space,
+    Apostrophe,
+    Comma,
+    Minus,
+    Period,
+    Slash,
+    Num0,
+    Num1,
+    Num2,
+    Num3,
+    Num4,
+    Num5,
+    Num6,
+    Num7,
+    Num8,
+    Num9,
+    Semicolon,
+    Equals,
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    G,
+    H,
+    I,
+    J,
+    K,
+    L,
+    M,
+    N,
+    O,
+    P,
+    Q,
+    R,
+    S,
+    T,
+    U,
+    V,
+    W,
+    X,
+    Y,
+    Z,
+    LeftBracket,
+    Backslash,
+    RightBracket,
+    GraveAccent,
+    World1,
+    World2,
+    Escape,
+    Enter,
+    Tab,
+    Backspace,
+    Insert,
+    Delete,
+    Right,
+    Left,
+    Down,
+    Up,
+    PageUp,
+    PageDown,
+    Home,
+    End,
+    CapsLock,
+    ScrollLock,
+    NumLock,
+    PrintScreen,
+    Pause,
+    F1,
+    F2,
+    F3,
+    F4,
+    F5,
+    F6,
+    F7,
+    F8,
+    F9,
+    F10,
+    F11,
+    F12,
+    F13,
+    F14,
+    F15,
+    F16,
+    F17,
+    F18,
+    F19,
+    F20,
+    F21,
+    F22,
+    F23,
+    F24,
+    F25,
+    KeyPad0,
+    KeyPad1,
+    KeyPad2,
+    KeyPad3,
+    KeyPad4,
+    KeyPad5,
+    KeyPad6,
+    KeyPad7,
+    KeyPad8,
+    KeyPad9,
+    KeyPadDecimal,
+    KeyPadDivide,
+    KeyPadMultiply,
+    KeyPadSubtract,
+    KeyPadAdd,
+    KeyPadEnter,
+    KeyPadEqual,
+    Menu
+};
+
+enum Keys scanCodeToKey(int scanCode);
+int keyToScanCode(enum Keys key);

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

@@ -8,7 +8,7 @@
 #include <wolv/io/file.hpp>
 #include <wolv/utils/guards.hpp>
 
-namespace hex::log {
+EXPORT_MODULE namespace hex::log {
 
     namespace impl {
 

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

@@ -0,0 +1,25 @@
+#pragma once
+#include <hex/api/shortcut_manager.hpp>
+
+namespace hex::menu {
+
+    void enableNativeMenuBar(bool enabled);
+    bool isNativeMenuBarUsed();
+
+    bool beginMainMenuBar();
+    void endMainMenuBar();
+
+    bool beginMenu(const char *label, bool enabled = true);
+    void endMenu();
+
+    bool beginMenuEx(const char* label, const char* icon, bool enabled = true);
+
+    bool menuItem(const char *label, const Shortcut &shortcut = Shortcut::None, bool selected = false, bool enabled = true);
+    bool menuItem(const char *label, const Shortcut &shortcut, bool *selected, bool enabled = true);
+
+    bool menuItemEx(const char *label, const char *icon, const Shortcut &shortcut = Shortcut::None, bool selected = false, bool enabled = true);
+    bool menuItemEx(const char *label, const char *icon, const Shortcut &shortcut, bool *selected, bool enabled = true);
+
+    void menuSeparator();
+
+}

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

@@ -9,9 +9,9 @@
 #include <map>
 #include <span>
 #include <string>
+#include <numbers>
 
 #include <opengl_support.h>
-#include <GLFW/glfw3.h>
 #include "imgui.h"
 
 namespace hex::gl {
@@ -188,43 +188,43 @@ namespace hex::gl {
 
 
         T &getElement(int row,int col) {
-            return this->mat[row*Columns+col];
+            return this->mat[row * Columns+col];
         }
 
         Vector<T,Rows> getColumn(int col) {
             Vector<T,Rows> result;
             for (size_t i = 0; i < Rows; i++)
-                result[i] = this->mat[i*Columns+col];
+                result[i] = this->mat[i * Columns + col];
             return result;
         }
 
         Vector<T,Columns> getRow(int row) {
             Vector<T,Columns> result;
             for (size_t i = 0; i < Columns; i++)
-                result[i] = this->mat[row*Columns+i];
+                result[i] = this->mat[row * Columns+i];
             return result;
         }
 
         void updateRow(int row, Vector<T,Columns> values) {
             for (size_t i = 0; i < Columns; i++)
-                this->mat[row*Columns+i] = values[i];
+                this->mat[row * Columns + i] = values[i];
         }
 
         void updateColumn(int col, Vector<T,Rows> values) {
             for (size_t i = 0; i < Rows; i++)
-                this->mat[i*Columns+col] = values[i];
+                this->mat[i * Columns + col] = values[i];
         }
 
-        void updateElement( int row,int col, T value) {
-            this->mat[row*Columns + col] = value;
+        void updateElement(int row, int col, T value) {
+            this->mat[row * Columns + col] = value;
         }
 
-        T &operator()( const int &row,const int &col) {
-            return this->mat[row*Columns + col];
+        T &operator()(const unsigned &row, const unsigned &col) {
+            return this->mat[row * Columns + col];
         }
 
-        const T &operator()(const unsigned& row,const unsigned& col ) const {
-            return this->mat[row*Columns + col];
+        const T &operator()(const unsigned &row, const unsigned &col) const {
+            return this->mat[row * Columns + col];
         }
 
         Matrix& operator=(const Matrix& A) {
@@ -242,7 +242,7 @@ namespace hex::gl {
 
             for (size_t i = 0; i < Rows; i++)
                 for (size_t j = 0; j < Columns; j++)
-                    result(i, j) = this->mat[i*Columns+j] + A(i, j);
+                    result(i, j) = this->mat[i * Columns + j] + A(i, j);
             return result;
         }
 
@@ -251,7 +251,7 @@ namespace hex::gl {
 
             for (size_t i = 0; i < Rows; i++)
                 for (size_t j = 0; j < Columns; j++)
-                    result(i, j) = this->mat[i*Columns+j] - A(i, j);
+                    result(i, j) = this->mat[i * Columns + j] - A(i, j);
             return result;
         }
 
@@ -268,7 +268,7 @@ namespace hex::gl {
             Matrix  t(0);
             for (size_t i = 0; i < Columns; i++)
                 for (size_t j = 0; j < Rows; j++)
-                    t.updateElement(i, j, this->mat[j*Rows+i]);
+                    t.updateElement(i, j, this->mat[j * Rows + i]);
 
             return t;
         }
@@ -400,8 +400,8 @@ namespace hex::gl {
 
         T Sx, Cx, Sy, Cy, Sz, Cz;
         Vector<T,3> angles = ypr;
-        if(!radians)
-            angles *= M_PI/180;
+        if (!radians)
+            angles *= std::numbers::pi_v<T> / 180;
 
         Sx = -sin(angles[0]); Cx = cos(angles[0]);
         Sy = -sin(angles[1]); Cy = cos(angles[1]);
@@ -524,7 +524,7 @@ namespace hex::gl {
         Vector<T,3> rotationVector3 = {{rotationVector[0], rotationVector[1], rotationVector[2]}};
         T theta = rotationVector3.magnitude();
         if (!radians)
-            theta *= M_PI / 180;
+            theta *= std::numbers::pi / 180;
         Vector<T,3> axis = rotationVector3;
         if (theta != 0)
             axis = axis.normalize();
@@ -807,16 +807,18 @@ namespace hex::gl {
         void bind() const;
         void unbind() const;
 
+        bool isValid() const { return m_program != 0; }
+
         void setUniform(std::string_view name, const int &value);
         void setUniform(std::string_view name, const float &value);
 
         template<size_t N>
         void setUniform(std::string_view name, const Vector<float, N> &value) {
-            if (N == 2)
+            if constexpr (N == 2)
                 glUniform2f(getUniformLocation(name), value[0], value[1]);
-            else if (N == 3)
+            else if constexpr (N == 3)
                 glUniform3f(getUniformLocation(name), value[0], value[1], value[2]);
-            else if (N == 4)
+            else if constexpr (N == 4)
                 glUniform4f(getUniformLocation(name), value[0], value[1], value[2],value[3]);
         }
 

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

@@ -6,7 +6,7 @@
 #include <string>
 #include <vector>
 
-namespace hex {
+EXPORT_MODULE namespace hex {
 
     class SemanticVersion {
     public:

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

@@ -6,17 +6,10 @@
 #include <concepts>
 #include <type_traits>
 
-using u8   = std::uint8_t;
-using u16  = std::uint16_t;
-using u32  = std::uint32_t;
-using u64  = std::uint64_t;
-using u128 = __uint128_t;
+#include <wolv/types.hpp>
 
-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 namespace wolv::unsigned_integers;
+using namespace wolv::signed_integers;
 
 using color_t = u32;
 

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

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <functional>
+#include <thread>
+#include <atomic>
+#include <span>
+
+namespace hex {
+
+    class UDPServer {
+    public:
+        using Callback = std::function<void(std::span<const u8> data)>;
+        UDPServer() = default;
+        UDPServer(u16 port, Callback callback);
+        ~UDPServer();
+
+        UDPServer(const UDPServer&) = delete;
+        UDPServer& operator=(const UDPServer&) = delete;
+        UDPServer(UDPServer &&other) noexcept {
+            m_port = other.m_port;
+            m_callback = std::move(other.m_callback);
+            m_thread = std::move(other.m_thread);
+            m_running = other.m_running.load();
+            other.m_running = false;
+            m_socketFd = other.m_socketFd;
+            other.m_socketFd = -1;
+        }
+        UDPServer& operator=(UDPServer &&other) noexcept {
+            if (this != &other) {
+                m_port = other.m_port;
+                m_callback = std::move(other.m_callback);
+                m_thread = std::move(other.m_thread);
+                m_running = other.m_running.load();
+                other.m_running = false;
+                m_socketFd = other.m_socketFd;
+                other.m_socketFd = -1;
+            }
+
+            return *this;
+        }
+
+        void start();
+        void stop();
+
+        [[nodiscard]] u16 getPort() const { return m_port; }
+
+    private:
+        void run();
+
+        u16 m_port;
+        Callback m_callback;
+        std::thread m_thread;
+        std::atomic<bool> m_running;
+        int m_socketFd;
+    };
+
+}

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

@@ -26,18 +26,20 @@
     #include <hex/helpers/utils_linux.hpp>
 #endif
 
-struct ImVec2;
+#include <imgui.h>
 
 namespace hex {
 
-    namespace prv {
-        class Provider;
-    }
+    #if !defined(HEX_MODULE_EXPORT)
+        namespace prv {
+            class Provider;
+        }
+    #endif
 
     template<typename T>
     [[nodiscard]] std::vector<std::vector<T>> sampleChannels(const std::vector<T> &data, size_t count, size_t channels) {
         if (channels == 0) return {};
-        size_t signalLength = std::max(1.0, double(data.size()) / channels);
+        size_t signalLength = std::max<double>(1.0, double(data.size()) / channels);
 
         size_t stride = std::max(1.0, double(signalLength) / count);
 
@@ -109,13 +111,13 @@ namespace hex {
     [[nodiscard]] std::wstring utf8ToUtf16(const std::string& utf8);
     [[nodiscard]] std::string utf16ToUtf8(const std::wstring& utf16);
 
-    [[nodiscard]] constexpr u64 extract(u8 from, u8 to, const std::unsigned_integral auto &value) {
+    [[nodiscard]] constexpr u64 extract(u8 from, u8 to, const auto &value) {
         if (from < to) std::swap(from, to);
 
         using ValueType = std::remove_cvref_t<decltype(value)>;
         ValueType mask  = (std::numeric_limits<ValueType>::max() >> (((sizeof(value) * 8) - 1) - (from - to))) << to;
 
-        return (value & mask) >> to;
+        return u64((value & mask) >> to);
     }
 
     [[nodiscard]] inline u64 extract(u32 from, u32 to, const std::vector<u8> &bytes) {
@@ -278,7 +280,7 @@ namespace hex {
 
         std::string result;
         for (i16 bit = hex::bit_width(number) - 1; bit >= 0; bit -= 1)
-            result += (number & (0b1 << bit)) == 0 ? '0' : '1';
+            result += (number & (0b1LLU << bit)) == 0 ? '0' : '1';
 
         return result;
     }
@@ -340,4 +342,6 @@ namespace hex {
      */
     [[nodiscard]] void* getContainingModule(void* symbol);
 
+    [[nodiscard]] std::optional<ImColor> blendColors(const std::optional<ImColor> &a, const std::optional<ImColor> &b);
+
 }

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

@@ -1,8 +1,12 @@
 #pragma once
 
+#include <hex/helpers/keys.hpp>
+
 #if defined(OS_MACOS)
 
-    struct GLFWwindow;
+    #if !defined(HEX_MODULE_EXPORT)
+        struct GLFWwindow;
+    #endif
 
     extern "C" {
 
@@ -17,8 +21,15 @@
         void enumerateFontsMacos();
     
         void macosHandleTitlebarDoubleClickGesture(GLFWwindow *window);
+        void macosSetWindowMovable(GLFWwindow *window, bool movable);
         bool macosIsWindowBeingResizedByUser(GLFWwindow *window);
         void macosMarkContentEdited(GLFWwindow *window, bool edited = true);
+
+        void macosGetKey(Keys key, int *output);
+
+        bool macosIsMainInstance();
+        void macosSendMessageToMainInstance(const unsigned char *data, size_t size);
+        void macosInstallEventListener();
     }
 
 #endif

lib/libimhex/include/hex/plugin.hpp

@@ -13,6 +13,13 @@
 #include <wolv/utils/preproc.hpp>
 #include <wolv/utils/guards.hpp>
 
+#if defined(_MSC_VER)
+    #include <windows.h>
+    #define PLUGIN_ENTRY_POINT extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) { return TRUE; }
+#else
+    #define PLUGIN_ENTRY_POINT
+#endif
+
 namespace {
     struct PluginFunctionHelperInstantiation {};
 }
@@ -45,7 +52,11 @@ void* PluginSubCommandsFunctionHelper<T>::getSubCommands() {
 #if defined (IMHEX_STATIC_LINK_PLUGINS)
     #define IMHEX_PLUGIN_VISIBILITY_PREFIX static
 #else
-    #define IMHEX_PLUGIN_VISIBILITY_PREFIX extern "C" [[gnu::visibility("default")]]
+    #if defined(_MSC_VER)
+        #define IMHEX_PLUGIN_VISIBILITY_PREFIX extern "C" __declspec(dllexport)
+    #else
+        #define IMHEX_PLUGIN_VISIBILITY_PREFIX extern "C" [[gnu::visibility("default")]]
+    #endif
 #endif
 
 #define IMHEX_FEATURE_ENABLED(feature) WOLV_TOKEN_CONCAT(WOLV_TOKEN_CONCAT(WOLV_TOKEN_CONCAT(IMHEX_PLUGIN_, IMHEX_PLUGIN_NAME), _FEATURE_), feature)
@@ -70,14 +81,13 @@ void* PluginSubCommandsFunctionHelper<T>::getSubCommands() {
 #define IMHEX_LIBRARY_SETUP(name) IMHEX_LIBRARY_SETUP_IMPL(name)
 
 #define IMHEX_LIBRARY_SETUP_IMPL(name)                                                                                          \
-    namespace { static struct EXIT_HANDLER { ~EXIT_HANDLER() { hex::log::info("Unloaded library '{}'", name); } } HANDLER; }    \
     IMHEX_PLUGIN_VISIBILITY_PREFIX void WOLV_TOKEN_CONCAT(initializeLibrary_, IMHEX_PLUGIN_NAME)();                             \
     IMHEX_PLUGIN_VISIBILITY_PREFIX const char *WOLV_TOKEN_CONCAT(getLibraryName_, IMHEX_PLUGIN_NAME)() { return name; }         \
     IMHEX_PLUGIN_VISIBILITY_PREFIX void WOLV_TOKEN_CONCAT(setImGuiContext_, IMHEX_PLUGIN_NAME)(ImGuiContext *ctx) {             \
         ImGui::SetCurrentContext(ctx);                                                                                          \
         GImGui = ctx;                                                                                                           \
     }                                                                                                                           \
-    extern "C" [[gnu::visibility("default")]] void WOLV_TOKEN_CONCAT(forceLinkPlugin_, IMHEX_PLUGIN_NAME)() {                   \
+    extern "C" void WOLV_TOKEN_CONCAT(forceLinkPlugin_, IMHEX_PLUGIN_NAME)() {                                                  \
         hex::PluginManager::addPlugin(name, hex::PluginFunctions {                                                              \
             nullptr,                                                                                                            \
             WOLV_TOKEN_CONCAT(initializeLibrary_, IMHEX_PLUGIN_NAME),                                                           \
@@ -92,10 +102,10 @@ void* PluginSubCommandsFunctionHelper<T>::getSubCommands() {
             nullptr                                                                                                             \
         });                                                                                                                     \
     }                                                                                                                           \
+    PLUGIN_ENTRY_POINT                                                                                                          \
     IMHEX_PLUGIN_VISIBILITY_PREFIX void WOLV_TOKEN_CONCAT(initializeLibrary_, IMHEX_PLUGIN_NAME)()
 
 #define IMHEX_PLUGIN_SETUP_IMPL(name, author, description)                                                                      \
-    namespace { static struct EXIT_HANDLER { ~EXIT_HANDLER() { hex::log::debug("Unloaded plugin '{}'", name); } } HANDLER; }    \
     IMHEX_PLUGIN_VISIBILITY_PREFIX const char *getPluginName() { return name; }                                                 \
     IMHEX_PLUGIN_VISIBILITY_PREFIX const char *getPluginAuthor() { return author; }                                             \
     IMHEX_PLUGIN_VISIBILITY_PREFIX const char *getPluginDescription() { return description; }                                   \
@@ -112,7 +122,7 @@ void* PluginSubCommandsFunctionHelper<T>::getSubCommands() {
         return PluginSubCommandsFunctionHelper<PluginFunctionHelperInstantiation>::getSubCommands();                            \
     }                                                                                                                           \
     IMHEX_PLUGIN_VISIBILITY_PREFIX void initializePlugin();                                                                     \
-    extern "C" [[gnu::visibility("default")]] void WOLV_TOKEN_CONCAT(forceLinkPlugin_, IMHEX_PLUGIN_NAME)() {                   \
+    extern "C" void WOLV_TOKEN_CONCAT(forceLinkPlugin_, IMHEX_PLUGIN_NAME)() {                                                  \
         hex::PluginManager::addPlugin(name, hex::PluginFunctions {                                                              \
             initializePlugin,                                                                                                   \
             nullptr,                                                                                                            \
@@ -127,6 +137,7 @@ void* PluginSubCommandsFunctionHelper<T>::getSubCommands() {
             getFeatures                                                                                                         \
         });                                                                                                                     \
     }                                                                                                                           \
+    PLUGIN_ENTRY_POINT                                                                                                          \
     IMHEX_PLUGIN_VISIBILITY_PREFIX void initializePlugin()
 
 /**

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

@@ -38,7 +38,7 @@ namespace hex::prv {
 
         [[nodiscard]] std::string getName() const override { return m_name; }
 
-        [[nodiscard]] std::string getTypeName() const override { return "MemoryProvider"; }
+        [[nodiscard]] UnlocalizedString getTypeName() const override { return "MemoryProvider"; }
     private:
         void renameFile();
 

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

@@ -30,6 +30,7 @@ namespace hex::prv {
 
         struct MenuEntry {
             std::string name;
+            const char *icon;
             std::function<void()> callback;
         };
 
@@ -113,7 +114,7 @@ namespace hex::prv {
          * @param size number of bytes to read
          * @param overlays apply overlays and patches is true. Same as readRaw() if false
          */
-        void read(u64 offset, void *buffer, size_t size, bool overlays = true);
+        virtual void read(u64 offset, void *buffer, size_t size, bool overlays = true);
         
         /**
          * @brief Write data to the patches of this provider. Will not directly modify provider.
@@ -121,7 +122,7 @@ namespace hex::prv {
          * @param buffer buffer to take data to write from
          * @param size number of bytes to write
          */
-        void write(u64 offset, const void *buffer, size_t size);
+        virtual void write(u64 offset, const void *buffer, size_t size);
 
         /**
          * @brief Read data from this provider, without applying overlays and patches
@@ -151,7 +152,7 @@ namespace hex::prv {
          * like "hex.builtin.provider.mem_file" or "hex.builtin.provider.file"
          * @return The provider's type name
          */
-        [[nodiscard]] virtual std::string getTypeName() const = 0;
+        [[nodiscard]] virtual UnlocalizedString getTypeName() const = 0;
 
         /**
          * @brief Gets a human readable representation of the current provider
@@ -193,11 +194,11 @@ namespace hex::prv {
         [[nodiscard]] virtual std::vector<Description> getDataDescription() const;
         [[nodiscard]] virtual std::variant<std::string, i128> queryInformation(const std::string &category, const std::string &argument);
 
-        void undo();
-        void redo();
+        virtual void undo();
+        virtual void redo();
 
-        [[nodiscard]] bool canUndo() const;
-        [[nodiscard]] bool canRedo() const;
+        [[nodiscard]] virtual bool canUndo() const;
+        [[nodiscard]] virtual bool canRedo() const;
 
         [[nodiscard]] virtual bool hasFilePicker() const;
         virtual bool handleFilePicker();
@@ -231,7 +232,7 @@ namespace hex::prv {
             return m_undoRedoStack.add<T>(std::forward<decltype(args)...>(args)...);
         }
 
-        [[nodiscard]] undo::Stack& getUndoStack() { return m_undoRedoStack; }
+        [[nodiscard]] virtual undo::Stack& getUndoStack() { return m_undoRedoStack; }
 
     protected:
         u32 m_currPage    = 0;

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

@@ -1,7 +1,10 @@
 #pragma once
 
 #include <hex/api/imhex_api.hpp>
-#include <hex/api/event_manager.hpp>
+#include <hex/api/events/events_provider.hpp>
+#include <hex/api/events/events_lifecycle.hpp>
+#include <hex/api/events/requests_provider.hpp>
+
 
 #include <map>
 #include <ranges>
@@ -9,9 +12,11 @@
 
 namespace hex {
 
-    namespace prv {
-        class Provider;
-    }
+    #if !defined(HEX_MODULE_EXPORT)
+        namespace prv {
+            class Provider;
+        }
+    #endif
 
     template<typename T>
     class PerProvider {
@@ -33,18 +38,30 @@ namespace hex {
         }
 
         T& get(const prv::Provider *provider = ImHexApi::Provider::get()) {
+            if (provider == nullptr) [[unlikely]]
+                throw std::invalid_argument("PerProvider::get called with nullptr");
+
             return m_data[provider];
         }
 
         const T& get(const prv::Provider *provider = ImHexApi::Provider::get()) const {
+            if (provider == nullptr) [[unlikely]]
+                throw std::invalid_argument("PerProvider::get called with nullptr");
+
             return m_data.at(provider);
         }
 
         void set(const T &data, const prv::Provider *provider = ImHexApi::Provider::get()) {
+            if (provider == nullptr) [[unlikely]]
+                throw std::invalid_argument("PerProvider::set called with nullptr");
+
             m_data[provider] = data;
         }
 
         void set(T &&data, const prv::Provider *provider = ImHexApi::Provider::get()) {
+            if (provider == nullptr) [[unlikely]]
+                throw std::invalid_argument("PerProvider::set called with nullptr");
+
             m_data[provider] = std::move(data);
         }
 

lib/libimhex/include/hex/providers/undo_redo/stack.hpp

@@ -2,7 +2,6 @@
 
 #include <hex.hpp>
 #include <hex/api/localization_manager.hpp>
-#include <hex/api/event_manager.hpp>
 
 #include <hex/providers/undo_redo/operations/operation.hpp>
 
@@ -35,7 +34,6 @@ namespace hex::prv::undo {
         template<std::derived_from<Operation> T>
         bool add(auto && ... args) {
             auto result = this->add(std::make_unique<T>(std::forward<decltype(args)>(args)...));
-            EventDataChanged::post(m_provider);
 
             return result;
         }

lib/libimhex/include/hex/test/test_provider.hpp

@@ -47,7 +47,7 @@ namespace hex::test {
             return m_data->size();
         }
 
-        [[nodiscard]] std::string getTypeName() const override { return "hex.test.provider.test"; }
+        [[nodiscard]] UnlocalizedString getTypeName() const override { return "hex.test.provider.test"; }
 
         bool open() override { return true; }
         void close() override { }

lib/libimhex/include/hex/ui/banner.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <hex.hpp>
+#include <imgui.h>
+#include <imgui_internal.h>
+#include <hex/helpers/utils.hpp>
+
+#include <list>
+#include <memory>
+#include <mutex>
+#include "hex/api/localization_manager.hpp"
+
+namespace hex {
+
+    namespace impl {
+
+        class BannerBase {
+        public:
+            BannerBase(ImColor color) : m_color(color) {}
+            virtual ~BannerBase() = default;
+
+            virtual void draw() { drawContent(); }
+            virtual void drawContent() = 0;
+
+            [[nodiscard]] static std::list<std::unique_ptr<BannerBase>> &getOpenBanners();
+
+            [[nodiscard]] const ImColor& getColor() const {
+                return m_color;
+            }
+
+            void close() { m_shouldClose = true; }
+            [[nodiscard]] bool shouldClose() const { return m_shouldClose; }
+
+        protected:
+            static std::mutex& getMutex();
+
+            bool m_shouldClose = false;
+            ImColor m_color;
+        };
+
+    }
+
+    template<typename T>
+    class Banner : public impl::BannerBase {
+    public:
+        using impl::BannerBase::BannerBase;
+
+        template<typename ...Args>
+        static void open(Args && ... args) {
+            std::lock_guard lock(getMutex());
+
+            auto toast = std::make_unique<T>(std::forward<Args>(args)...);
+            getOpenBanners().emplace_back(std::move(toast));
+        }
+    };
+
+}

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

@@ -79,17 +79,16 @@ namespace ImGuiExt {
         Texture(const Texture&) = delete;
         Texture(Texture&& other) noexcept;
 
-        static Texture fromImage(const ImU8 *buffer, int size, Filter filter = Filter::Nearest);
-        static Texture fromImage(std::span<const std::byte> buffer, Filter filter = Filter::Nearest);
-        static Texture fromImage(const char *path, Filter filter = Filter::Nearest);
-        static Texture fromImage(const std::fs::path &path, Filter filter = Filter::Nearest);
-        static Texture fromGLTexture(unsigned int texture, int width, int height);
-        static Texture fromBitmap(const ImU8 *buffer, int size, int width, int height, Filter filter = Filter::Nearest);
-        static Texture fromBitmap(std::span<const std::byte> buffer, int width, int height, Filter filter = Filter::Nearest);
-        static Texture fromSVG(const char *path, int width = 0, int height = 0, Filter filter = Filter::Nearest);
-        static Texture fromSVG(const std::fs::path &path, int width = 0, int height = 0, Filter filter = Filter::Nearest);
-        static Texture fromSVG(std::span<const std::byte> buffer, int width = 0, int height = 0, Filter filter = Filter::Nearest);
-
+        [[nodiscard]] static Texture fromImage(const ImU8 *buffer, int size, Filter filter = Filter::Nearest);
+        [[nodiscard]] static Texture fromImage(std::span<const std::byte> buffer, Filter filter = Filter::Nearest);
+        [[nodiscard]] static Texture fromImage(const char *path, Filter filter = Filter::Nearest);
+        [[nodiscard]] static Texture fromImage(const std::fs::path &path, Filter filter = Filter::Nearest);
+        [[nodiscard]] static Texture fromGLTexture(unsigned int texture, int width, int height);
+        [[nodiscard]] static Texture fromBitmap(const ImU8 *buffer, int size, int width, int height, Filter filter = Filter::Nearest);
+        [[nodiscard]] static Texture fromBitmap(std::span<const std::byte> buffer, int width, int height, Filter filter = Filter::Nearest);
+        [[nodiscard]] static Texture fromSVG(const char *path, int width = 0, int height = 0, Filter filter = Filter::Nearest);
+        [[nodiscard]] static Texture fromSVG(const std::fs::path &path, int width = 0, int height = 0, Filter filter = Filter::Nearest);
+        [[nodiscard]] static Texture fromSVG(std::span<const std::byte> buffer, int width = 0, int height = 0, Filter filter = Filter::Nearest);
 
         ~Texture();
 
@@ -114,6 +113,10 @@ namespace ImGuiExt {
             return float(m_width) / float(m_height);
         }
 
+        [[nodiscard]] std::vector<u8> toBytes() const noexcept;
+
+        void reset();
+
     private:
         ImTextureID m_textureId = 0;
         int m_width = 0, m_height = 0;
@@ -144,13 +147,13 @@ namespace ImGuiExt {
 
     bool TitleBarButton(const char *label, ImVec2 size_arg);
     bool ToolBarButton(const char *symbol, ImVec4 color);
-    bool IconButton(const char *symbol, ImVec4 color, ImVec2 size_arg = ImVec2(0, 0));
+    bool IconButton(const char *symbol, ImVec4 color, ImVec2 size_arg = ImVec2(0, 0), ImVec2 iconOffset = ImVec2(0, 0));
 
     bool InputIntegerPrefix(const char* label, const char *prefix, void *value, ImGuiDataType type, const char *format, 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);
 
-    bool SliderBytes(const char *label, u64 *value, u64 min, u64 max, ImGuiSliderFlags flags = ImGuiSliderFlags_None);
+    bool SliderBytes(const char *label, u64 *value, u64 min, u64 max, u64 stepSize = 1, ImGuiSliderFlags flags = ImGuiSliderFlags_None);
 
     inline bool HasSecondPassed() {
         return static_cast<ImU32>(ImGui::GetTime() * 100) % 100 <= static_cast<ImU32>(ImGui::GetIO().DeltaTime * 100);
@@ -158,6 +161,8 @@ namespace ImGuiExt {
 
     void OpenPopupInWindow(const char *window_name, const char *popup_name);
 
+    void DisableWindowResize(ImGuiDir dir);
+
     struct ImHexCustomData {
         ImVec4 Colors[ImGuiCustomCol_COUNT];
 
@@ -183,7 +188,7 @@ namespace ImGuiExt {
     void StyleCustomColorsLight();
     void StyleCustomColorsClassic();
 
-    void SmallProgressBar(float fraction, float yOffset = 0.0F);
+    void ProgressBar(float fraction, ImVec2 size_value = ImVec2(0, 0), float yOffset = 0.0F);
 
     inline void TextFormatted(std::string_view fmt, auto &&...args) {
         if constexpr (sizeof...(args) == 0) {
@@ -200,14 +205,15 @@ namespace ImGuiExt {
         ImGui::PushID(text.c_str());
 
         ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2());
+        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0F);
         ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4());
 
         ImGui::PushItemWidth(ImGui::CalcTextSize(text.c_str()).x + ImGui::GetStyle().FramePadding.x * 2);
-        ImGui::InputText("##", const_cast<char *>(text.c_str()), text.size(), ImGuiInputTextFlags_ReadOnly | ImGuiInputTextFlags_NoHorizontalScroll);
+        ImGui::InputText("##", const_cast<char *>(text.c_str()), text.size() + 1, ImGuiInputTextFlags_ReadOnly | ImGuiInputTextFlags_NoHorizontalScroll);
         ImGui::PopItemWidth();
 
         ImGui::PopStyleColor();
-        ImGui::PopStyleVar();
+        ImGui::PopStyleVar(2);
 
         ImGui::PopID();
     }
@@ -235,29 +241,32 @@ namespace ImGuiExt {
 
     inline void TextFormattedWrappedSelectable(std::string_view fmt, auto &&...args) {
         // Manually wrap text, using the letter M (generally the widest character in non-monospaced fonts) to calculate the character width to use.
-        auto text = wolv::util::wrapMonospacedString(
+        auto text = wolv::util::trim(wolv::util::wrapMonospacedString(
                 hex::format(fmt, std::forward<decltype(args)>(args)...),
                 ImGui::CalcTextSize("M").x,
                 ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ScrollbarSize - ImGui::GetStyle().FrameBorderSize
-        );
+        ));
+
+        auto textSize = ImGui::CalcTextSize(text.c_str());
 
         ImGui::PushID(text.c_str());
 
         ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2());
+        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0F);
         ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4());
 
         ImGui::PushItemWidth(ImGui::CalcTextSize(text.c_str()).x + ImGui::GetStyle().FramePadding.x * 2);
         ImGui::InputTextMultiline(
                 "##",
                 const_cast<char *>(text.c_str()),
-                text.size(),
-                ImVec2(0, -FLT_MIN),
+                text.size() + 1,
+                ImVec2(0, textSize.y),
                 ImGuiInputTextFlags_ReadOnly | ImGuiInputTextFlags_NoHorizontalScroll
         );
         ImGui::PopItemWidth();
 
         ImGui::PopStyleColor();
-        ImGui::PopStyleVar();
+        ImGui::PopStyleVar(2);
 
         ImGui::PopID();
     }
@@ -291,8 +300,8 @@ namespace ImGuiExt {
     bool BitCheckbox(const char* label, bool* v);
 
     bool DimmedButton(const char* label, ImVec2 size = ImVec2(0, 0));
-    bool DimmedIconButton(const char *symbol, ImVec4 color, ImVec2 size = ImVec2(0, 0));
-    bool DimmedButtonToggle(const char *icon, bool *v, ImVec2 size);
+    bool DimmedIconButton(const char *symbol, ImVec4 color, ImVec2 size = ImVec2(0, 0), ImVec2 iconOffset = ImVec2(0, 0));
+    bool DimmedButtonToggle(const char *icon, bool *v, ImVec2 size = ImVec2(0, 0), ImVec2 iconOffset = ImVec2(0, 0));
     bool DimmedIconToggle(const char *icon, bool *v);
     bool DimmedIconToggle(const char *iconOn, const char *iconOff, bool *v);
 

lib/libimhex/include/hex/ui/view.hpp

@@ -8,7 +8,6 @@
 
 #include <hex/api/imhex_api.hpp>
 #include <hex/api/shortcut_manager.hpp>
-#include <hex/api/event_manager.hpp>
 #include <hex/api/localization_manager.hpp>
 
 #include <hex/providers/provider.hpp>
@@ -99,6 +98,14 @@ namespace hex {
 
         [[nodiscard]] static std::string toWindowName(const UnlocalizedString &unlocalizedName);
 
+        [[nodiscard]] bool isFocused() const { return m_focused; }
+
+        /**
+         * @brief Used for focus handling. Don't use this directly
+         * @param focused Whether this view is focused
+         */
+        void setFocused(bool focused) { m_focused = focused; }
+
     public:
         class Window;
         class Special;
@@ -111,6 +118,7 @@ namespace hex {
         std::map<Shortcut, ShortcutManager::ShortcutEntry> m_shortcuts;
         bool m_windowJustOpened = false;
         const char *m_icon;
+        bool m_focused = false;
 
         friend class ShortcutManager;
     };
@@ -175,7 +183,7 @@ namespace hex {
 
                 ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_Appearing, ImVec2(0.5F, 0.5F));
                 ImGui::SetNextWindowSizeConstraints(this->getMinSize(), this->getMaxSize());
-                if (ImGui::BeginPopupModal(View::toWindowName(this->getUnlocalizedName()).c_str(), this->hasCloseButton() ? &this->getWindowOpenState() : nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize | this->getWindowFlags())) {
+                if (ImGui::BeginPopupModal(View::toWindowName(this->getUnlocalizedName()).c_str(), this->hasCloseButton() ? &this->getWindowOpenState() : nullptr, ImGuiWindowFlags_NoCollapse | this->getWindowFlags())) {
                     this->drawContent();
 
                     ImGui::EndPopup();

lib/libimhex/source/api/achievement_manager.cpp

@@ -1,5 +1,5 @@
 #include <hex/api/achievement_manager.hpp>
-#include <hex/api/event_manager.hpp>
+#include <hex/api/events/events_interaction.hpp>
 
 #include <hex/helpers/auto_reset.hpp>
 #include <hex/helpers/default_paths.hpp>
@@ -12,13 +12,13 @@
 
 namespace hex {
 
-    static AutoReset<std::unordered_map<std::string, std::unordered_map<std::string, std::unique_ptr<Achievement>>>> s_achievements;
-    const std::unordered_map<std::string, std::unordered_map<std::string, std::unique_ptr<Achievement>>> &AchievementManager::getAchievements() {
+    static AutoReset<std::unordered_map<UnlocalizedString, std::unordered_map<UnlocalizedString, std::unique_ptr<Achievement>>>> s_achievements;
+    const std::unordered_map<UnlocalizedString, std::unordered_map<UnlocalizedString, std::unique_ptr<Achievement>>> &AchievementManager::getAchievements() {
         return *s_achievements;
     }
 
-    static AutoReset<std::unordered_map<std::string, std::list<AchievementManager::AchievementNode>>> s_nodeCategoryStorage;
-    std::unordered_map<std::string, std::list<AchievementManager::AchievementNode>>& getAchievementNodesMutable(bool rebuild) {
+    static AutoReset<std::unordered_map<UnlocalizedString, std::list<AchievementManager::AchievementNode>>> s_nodeCategoryStorage;
+    std::unordered_map<UnlocalizedString, std::list<AchievementManager::AchievementNode>>& getAchievementNodesMutable(bool rebuild) {
         if (!s_nodeCategoryStorage->empty() || !rebuild)
             return s_nodeCategoryStorage;
 
@@ -36,12 +36,12 @@ namespace hex {
         return s_nodeCategoryStorage;
     }
 
-    const std::unordered_map<std::string, std::list<AchievementManager::AchievementNode>>& AchievementManager::getAchievementNodes(bool rebuild) {
+    const std::unordered_map<UnlocalizedString, std::list<AchievementManager::AchievementNode>>& AchievementManager::getAchievementNodes(bool rebuild) {
         return getAchievementNodesMutable(rebuild);
     }
 
-    static AutoReset<std::unordered_map<std::string, std::vector<AchievementManager::AchievementNode*>>> s_startNodes;
-    const std::unordered_map<std::string, std::vector<AchievementManager::AchievementNode*>>& AchievementManager::getAchievementStartNodes(bool rebuild) {
+    static AutoReset<std::unordered_map<UnlocalizedString, std::vector<AchievementManager::AchievementNode*>>> s_startNodes;
+    const std::unordered_map<UnlocalizedString, std::vector<AchievementManager::AchievementNode*>>& AchievementManager::getAchievementStartNodes(bool rebuild) {
 
         if (!s_startNodes->empty() || !rebuild)
             return s_startNodes;
@@ -187,10 +187,10 @@ namespace hex {
         const auto &category = newAchievement->getUnlocalizedCategory();
         const auto &name = newAchievement->getUnlocalizedName();
 
-        auto [categoryIter, categoryInserted] = s_achievements->insert({ category, std::unordered_map<std::string, std::unique_ptr<Achievement>>{} });
+        auto [categoryIter, categoryInserted] = s_achievements->insert({ category, std::unordered_map<UnlocalizedString, std::unique_ptr<Achievement>>{} });
         auto &[categoryKey, achievements] = *categoryIter;
 
-        auto [achievementIter, achievementInserted] = achievements.insert({ name, std::move(newAchievement) });
+        auto [achievementIter, achievementInserted] = achievements.emplace(name, std::move(newAchievement));
         auto &[achievementKey, achievement] = *achievementIter;
 
         achievementAdded();
@@ -239,7 +239,7 @@ namespace hex {
 
                             achievement->setProgress(progress);
                         } catch (const std::exception &e) {
-                            log::warn("Failed to load achievement progress for '{}::{}': {}", categoryName, achievementName, e.what());
+                            log::warn("Failed to load achievement progress for '{}::{}': {}", categoryName.get(), achievementName.get(), e.what());
                         }
                     }
                 }

lib/libimhex/source/api/content_registry.cpp

@@ -1,5 +1,6 @@
 #include <hex/api/content_registry.hpp>
 #include <hex/api/shortcut_manager.hpp>
+#include <hex/api/events/requests_provider.hpp>
 
 #include <hex/helpers/fs.hpp>
 #include <hex/helpers/logger.hpp>
@@ -32,12 +33,40 @@ namespace hex {
         namespace impl {
 
             struct OnChange {
-                u32 id;
+                u64 id;
                 OnChangeCallback callback;
             };
 
             static AutoReset<std::map<std::string, std::map<std::string, std::vector<OnChange>>>> s_onChangeCallbacks;
 
+            static void runAllOnChangeCallbacks() {
+                for (const auto &[category, rest] : *impl::s_onChangeCallbacks) {
+                    for (const auto &[name, callbacks] : rest) {
+                        for (const auto &[id, callback] : callbacks) {
+                            try {
+                                callback(getSetting(category, name, {}));
+                            } catch (const std::exception &e) {
+                                log::error("Failed to load setting [{}/{}]: {}", category, name, e.what());
+                            }
+                        }
+                    }
+                }
+            }
+
+            void runOnChangeHandlers(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName, const nlohmann::json &value) {
+                if (auto categoryIt = s_onChangeCallbacks->find(unlocalizedCategory); categoryIt != s_onChangeCallbacks->end()) {
+                    if (auto nameIt = categoryIt->second.find(unlocalizedName); nameIt != categoryIt->second.end()) {
+                        for (const auto &[id, callback] : nameIt->second) {
+                            try {
+                                callback(value);
+                            } catch (const nlohmann::json::exception &e) {
+                                log::error("Failed to run onChange handler for setting {}/{}: {}", unlocalizedCategory.get(), unlocalizedName.get(), e.what());
+                            }
+                        }
+                    }
+                }
+            }
+
             static AutoReset<nlohmann::json> s_settings;
             const nlohmann::json& getSettingsData() {
                 return s_settings;
@@ -72,24 +101,28 @@ namespace hex {
                         s_settings = nlohmann::json::parse(data);
                     }
 
-                    for (const auto &[category, rest] : *impl::s_onChangeCallbacks) {
-                        for (const auto &[name, callbacks] : rest) {
-                            for (const auto &[id, callback] : callbacks) {
-                                try {
-                                    callback(getSetting(category, name, {}));
-                                } catch (const std::exception &e) {
-                                    log::error("Failed to load setting [{}/{}]: {}", category, name, e.what());
-                                }
-                            }
-                        }
-                    }
+                    runAllOnChangeCallbacks();
                 }
 
                 void store() {
-                    auto data = s_settings->dump();
+                    if (!s_settings.isValid())
+                        return;
+
+                    const auto &settingsData = *s_settings;
+
+                    // During a crash settings can be empty, causing them to be overwritten.
+                    if (settingsData.empty()) {
+                        return;
+                    }
+
+                    const auto result = settingsData.dump(4);
+                    if (result.empty()) {
+                        return;
+                    }
+
                     MAIN_THREAD_EM_ASM({
                         localStorage.setItem("config", UTF8ToString($0));
-                    }, data.c_str());
+                    }, result.c_str());
                 }
 
                 void clear() {
@@ -115,17 +148,7 @@ namespace hex {
                     if (!loaded)
                         store();
 
-                    for (const auto &[category, rest] : *impl::s_onChangeCallbacks) {
-                        for (const auto &[name, callbacks] : rest) {
-                            for (const auto &[id, callback] : callbacks) {
-                                try {
-                                    callback(getSetting(category, name, {}));
-                                } catch (const std::exception &e) {
-                                    log::error("Failed to load setting [{}/{}]: {}", category, name, e.what());
-                                }
-                            }
-                        }
-                    }
+                    runAllOnChangeCallbacks();
                 }
 
                 void store() {
@@ -135,7 +158,7 @@ namespace hex {
                     const auto &settingsData = *s_settings;
 
                     // During a crash settings can be empty, causing them to be overwritten.
-                    if (settingsData.empty()) {
+                    if (s_settings->empty()) {
                         return;
                     }
 
@@ -201,6 +224,8 @@ namespace hex {
                             log::error("Failed to load setting [{} / {}]: {}", unlocalizedCategory.get(), unlocalizedName.get(), e.what());
                         }
                     });
+
+                    runOnChangeHandlers(unlocalizedCategory, unlocalizedName, getSetting(unlocalizedCategory, unlocalizedName, entry->widget->store()));
                 }
 
                 return entry->widget.get();
@@ -210,20 +235,6 @@ namespace hex {
                 hex::log::error("Failed to read setting {}/{}: {}", unlocalizedCategory.get(), unlocalizedName.get(), e.what());
             }
 
-            void runOnChangeHandlers(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedName, const nlohmann::json &value) {
-                if (auto categoryIt = s_onChangeCallbacks->find(unlocalizedCategory); categoryIt != s_onChangeCallbacks->end()) {
-                    if (auto nameIt = categoryIt->second.find(unlocalizedName); nameIt != categoryIt->second.end()) {
-                        for (const auto &[id, callback] : nameIt->second) {
-                            try {
-                                callback(value);
-                            } catch (const nlohmann::json::exception &e) {
-                                log::error("Failed to run onChange handler for setting {}/{}: {}", unlocalizedCategory.get(), unlocalizedName.get(), e.what());
-                            }
-                        }
-                    }
-                }
-            }
-
         }
 
         void setCategoryDescription(const UnlocalizedString &unlocalizedCategory, const UnlocalizedString &unlocalizedDescription) {
@@ -325,7 +336,7 @@ namespace hex {
 
 
             bool SliderDataSize::draw(const std::string &name) {
-                return ImGuiExt::SliderBytes(name.c_str(), &m_value, m_min, m_max);
+                return ImGuiExt::SliderBytes(name.c_str(), &m_value, m_min, m_max, m_stepSize);
             }
 
             void SliderDataSize::load(const nlohmann::json &data) {
@@ -341,17 +352,34 @@ namespace hex {
             }
 
 
-            ColorPicker::ColorPicker(ImColor defaultColor) {
-                m_value = {
-                        defaultColor.Value.x,
-                        defaultColor.Value.y,
-                        defaultColor.Value.z,
-                        defaultColor.Value.w
+            ColorPicker::ColorPicker(ImColor defaultColor, ImGuiColorEditFlags flags) {
+                m_defaultValue = m_value = {
+                    defaultColor.Value.x,
+                    defaultColor.Value.y,
+                    defaultColor.Value.z,
+                    defaultColor.Value.w
                 };
+                m_flags = flags;
             }
 
             bool ColorPicker::draw(const std::string &name) {
-                return ImGui::ColorEdit4(name.c_str(), m_value.data(), ImGuiColorEditFlags_NoInputs);
+                ImGui::PushID(name.c_str());
+                auto result = ImGui::ColorEdit4("##color_picker", m_value.data(), ImGuiColorEditFlags_NoInputs | m_flags);
+
+                ImGui::SameLine();
+
+                if (ImGui::Button("X", ImGui::GetStyle().FramePadding * 2 + ImVec2(ImGui::GetTextLineHeight(), ImGui::GetTextLineHeight()))) {
+                    m_value = m_defaultValue;
+                    result = true;
+                }
+
+                ImGui::SameLine();
+
+                ImGui::TextUnformatted(name.c_str());
+
+                ImGui::PopID();
+
+                return result;
             }
 
             void ColorPicker::load(const nlohmann::json &data) {
@@ -377,7 +405,7 @@ namespace hex {
             bool DropDown::draw(const std::string &name) {
                 auto preview = "";
                 if (static_cast<size_t>(m_value) < m_items.size())
-                    preview = m_items[m_value].c_str();
+                    preview = m_items[m_value].get().c_str();
 
                 bool changed = false;
                 if (ImGui::BeginCombo(name.c_str(), Lang(preview))) {
@@ -686,15 +714,15 @@ namespace hex {
 
         namespace impl {
 
-            static AutoReset<std::map<std::string, std::unique_ptr<View>>> s_views;
-            const std::map<std::string, std::unique_ptr<View>>& getEntries() {
+            static AutoReset<std::map<UnlocalizedString, std::unique_ptr<View>>> s_views;
+            const std::map<UnlocalizedString, std::unique_ptr<View>>& getEntries() {
                 return *s_views;
             }
 
             void add(std::unique_ptr<View> &&view) {
             log::debug("Registered new view: {}", view->getUnlocalizedName().get());
 
-            s_views->insert({ view->getUnlocalizedName(), std::move(view) });
+            s_views->emplace(view->getUnlocalizedName(), std::move(view));
         }
 
         }
@@ -708,6 +736,15 @@ namespace hex {
                 return nullptr;
         }
 
+        View* getFocusedView() {
+            for (const auto &[unlocalizedName, view] : *impl::s_views) {
+                if (view->isFocused())
+                    return view.get();
+            }
+
+            return nullptr;
+        }
+
     }
 
     namespace ContentRegistry::Tools {
@@ -752,6 +789,14 @@ namespace hex {
             impl::s_entries->push_back({ unlocalizedName, requiredSize, maxSize, std::move(displayGeneratorFunction), std::move(editingFunction) });
         }
 
+        void drawMenuItems(const std::function<void()> &function) {
+            if (ImGui::BeginPopup("##DataInspectorRowContextMenu")) {
+                function();
+                ImGui::Separator();
+                ImGui::EndPopup();
+            }
+        }
+
     }
 
     namespace ContentRegistry::DataProcessorNode {
@@ -917,17 +962,10 @@ namespace hex {
             });
 
             if (shortcut != Shortcut::None) {
-                auto callbackIfEnabled  = [enabledCallback, function]{ if (enabledCallback()) { function(); } };
-
-                const auto unlocalizedShortcutName =
-                    unlocalizedMainMenuNames.size() == 1 ?
-                        std::vector { unlocalizedMainMenuNames.back() } :
-                        std::vector(unlocalizedMainMenuNames.begin() + 1, unlocalizedMainMenuNames.end());
-
                 if (shortcut.isLocal() && view != nullptr)
-                    ShortcutManager::addShortcut(view, shortcut, unlocalizedShortcutName, callbackIfEnabled);
+                    ShortcutManager::addShortcut(view, shortcut, unlocalizedMainMenuNames, function, enabledCallback);
                 else
-                    ShortcutManager::addGlobalShortcut(shortcut, unlocalizedShortcutName, callbackIfEnabled);
+                    ShortcutManager::addGlobalShortcut(shortcut, unlocalizedMainMenuNames, function, enabledCallback);
             }
         }
 
@@ -1097,7 +1135,9 @@ namespace hex {
 
     namespace ContentRegistry::HexEditor {
 
-        const int DataVisualizer::TextInputFlags = ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoHorizontalScroll | ImGuiInputTextFlags_AlwaysOverwrite;
+        int DataVisualizer::DefaultTextInputFlags() {
+            return ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoHorizontalScroll | ImGuiInputTextFlags_AlwaysOverwrite;
+        }
 
         bool DataVisualizer::drawDefaultScalarEditingTextBox(u64 address, const char *format, ImGuiDataType dataType, u8 *data, ImGuiInputTextFlags flags) const {
             struct UserData {
@@ -1115,7 +1155,7 @@ namespace hex {
             };
 
             ImGui::PushID(reinterpret_cast<void*>(address));
-            ImGuiExt::InputScalarCallback("##editing_input", dataType, data, format, flags | TextInputFlags | ImGuiInputTextFlags_CallbackEdit, [](ImGuiInputTextCallbackData *data) -> int {
+            ImGuiExt::InputScalarCallback("##editing_input", dataType, data, format, flags | DefaultTextInputFlags() | ImGuiInputTextFlags_CallbackEdit, [](ImGuiInputTextCallbackData *data) -> int {
                 auto &userData = *static_cast<UserData*>(data->UserData);
 
                 if (data->CursorPos >= userData.maxChars)
@@ -1146,7 +1186,7 @@ namespace hex {
             };
 
             ImGui::PushID(reinterpret_cast<void*>(address));
-            ImGui::InputText("##editing_input", data.data(), data.size() + 1, flags | TextInputFlags | ImGuiInputTextFlags_CallbackEdit, [](ImGuiInputTextCallbackData *data) -> int {
+            ImGui::InputText("##editing_input", data.data(), data.size() + 1, flags | DefaultTextInputFlags() | ImGuiInputTextFlags_CallbackEdit, [](ImGuiInputTextCallbackData *data) -> int {
                 auto &userData = *static_cast<UserData*>(data->UserData);
 
                 userData.data->resize(data->BufSize);
@@ -1391,4 +1431,23 @@ namespace hex {
 
     }
 
+    namespace ContentRegistry::Disassembler {
+
+        namespace impl {
+
+            static AutoReset<std::map<std::string, impl::CreatorFunction>> s_architectures;
+
+            void addArchitectureCreator(impl::CreatorFunction function) {
+                const auto arch = function();
+                (*s_architectures)[arch->getName()] = std::move(function);
+            }
+
+            const std::map<std::string, impl::CreatorFunction>& getArchitectures() {
+                return *s_architectures;
+            }
+
+        }
+
+    }
+
 }

lib/libimhex/source/api/imhex_api.cpp

@@ -1,6 +1,14 @@
 #include <hex/api/imhex_api.hpp>
 
-#include <hex/api/event_manager.hpp>
+#include <hex/api/events/events_provider.hpp>
+#include <hex/api/events/events_lifecycle.hpp>
+#include <hex/api/events/events_gui.hpp>
+#include <hex/api/events/requests_interaction.hpp>
+#include <hex/api/events/requests_lifecycle.hpp>
+#include <hex/api/events/requests_provider.hpp>
+#include <hex/api/events/requests_gui.hpp>
+#include <hex/api/events/events_interaction.hpp>
+
 #include <hex/api/task_manager.hpp>
 #include <hex/helpers/fmt.hpp>
 #include <hex/helpers/utils.hpp>
@@ -11,6 +19,7 @@
 #include <wolv/utils/string.hpp>
 
 #include <utility>
+#include <numeric>
 
 #include <imgui.h>
 #include <imgui_internal.h>
@@ -18,13 +27,20 @@
 #include <algorithm>
 #include <GLFW/glfw3.h>
 
+#include <hex/helpers/utils_macos.hpp>
+
 #if defined(OS_WINDOWS)
     #include <windows.h>
+    #include <DSRole.h>
 #else
     #include <sys/utsname.h>
     #include <unistd.h>
 #endif
 
+#if defined(OS_WEB)
+    #include <emscripten.h>
+#endif
+
 namespace hex {
 
 
@@ -86,6 +102,9 @@ namespace hex {
 
             static PerProvider<std::optional<Region>> s_hoveredRegion;
             void setHoveredRegion(const prv::Provider *provider, const Region &region) {
+                if (provider == nullptr)
+                    return;
+                
                 if (region == Region::Invalid())
                     s_hoveredRegion.get(provider).reset();
                 else
@@ -447,7 +466,7 @@ namespace hex {
             if (s_providers->empty())
                 EventProviderChanged::post(provider, nullptr);
 
-            EventProviderClosed::post(it->get());
+            EventProviderClosed::post(providerToRemove);
             RequestUpdateWindowTitle::post();
 
             // Do the destruction of the provider in the background once all tasks have finished
@@ -559,13 +578,22 @@ namespace hex {
                 return s_windowResizable;
             }
 
-            static std::vector<hex::impl::AutoResetBase*> s_autoResetObjects;
+            static auto& getAutoResetObjects() {
+                static std::set<hex::impl::AutoResetBase*> autoResetObjects;
+
+                return autoResetObjects;
+            }
+
             void addAutoResetObject(hex::impl::AutoResetBase *object) {
-                s_autoResetObjects.emplace_back(object);
+                getAutoResetObjects().insert(object);
+            }
+
+            void removeAutoResetObject(hex::impl::AutoResetBase *object) {
+                getAutoResetObjects().erase(object);
             }
 
             void cleanup() {
-                for (const auto &object : s_autoResetObjects)
+                for (const auto &object : getAutoResetObjects())
                     object->reset();
             }
 
@@ -608,6 +636,28 @@ namespace hex {
             return impl::s_nativeScale;
         }
 
+        float getBackingScaleFactor() {
+            #if defined(OS_WINDOWS)
+                return 1.0F;
+            #elif defined(OS_MACOS)
+                return ::getBackingScaleFactor();
+            #elif defined(OS_LINUX)
+                const auto sessionType = hex::getEnvironmentVariable("XDG_SESSION_TYPE");
+                if (!sessionType.has_value() || sessionType == "x11")
+                    return 1.0F;
+                else {
+                    float xScale = 0, yScale = 0;
+                    glfwGetMonitorContentScale(glfwGetPrimaryMonitor(), &xScale, &yScale);
+
+                    return std::midpoint(xScale, yScale);
+                }
+            #elif defined(OS_WEB)
+                return 1.0F;
+            #else
+                return 1.0F;
+            #endif
+        }
+
 
         ImVec2 getMainWindowPosition() {
             if ((ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable) != ImGuiConfigFlags_None)
@@ -697,6 +747,28 @@ namespace hex {
             return impl::s_glRenderer;
         }
 
+        bool isCorporateEnvironment() {
+            #if defined(OS_WINDOWS)
+                {
+                    DSROLE_PRIMARY_DOMAIN_INFO_BASIC * info;
+                    if ((DsRoleGetPrimaryDomainInformation(NULL, DsRolePrimaryDomainInfoBasic, (PBYTE *)&info) == ERROR_SUCCESS) && (info != nullptr))
+                    {
+                        bool result = std::wstring(info->DomainNameFlat) != L"WORKGROUP";
+                        DsRoleFreeMemory(info);
+
+                        return result;
+                    } else {
+                        DWORD size = 128;
+                        char buffer[128];
+                        ::GetComputerNameExA(ComputerNameDnsDomain, buffer, &size);
+                        return size > 0;
+                    }
+                }
+            #else
+                return false;
+            #endif
+        }
+
         bool isPortableVersion() {
             static std::optional<bool> portable;
             if (portable.has_value())
@@ -804,7 +876,8 @@ namespace hex {
 
         SemanticVersion getImHexVersion() {
             #if defined IMHEX_VERSION
-                return SemanticVersion(IMHEX_VERSION);
+                static auto version = SemanticVersion(IMHEX_VERSION);
+                return version;
             #else
                 return {};
             #endif
@@ -868,7 +941,7 @@ namespace hex {
             }
 
             EventImHexClosing::subscribe([executablePath, updateTypeString] {
-                hex::executeCommand(
+                hex::startProgram(
                         hex::format("\"{}\" \"{}\"",
                                     wolv::util::toUTF8String(executablePath),
                                     updateTypeString
@@ -938,11 +1011,6 @@ namespace hex {
                 return *s_fonts;
             }
 
-            static AutoReset<std::fs::path> s_customFontPath;
-            void setCustomFontPath(const std::fs::path &path) {
-                s_customFontPath = path;
-            }
-
             static float s_fontSize = DefaultFontSize;
             void setFontSize(float size) {
                 s_fontSize = size;
@@ -960,6 +1028,10 @@ namespace hex {
                 s_italicFont = italic;
             }
 
+            static AutoReset<std::map<UnlocalizedString, ImFont*>> s_fontDefinitions;
+            std::map<UnlocalizedString, ImFont*>& getFontDefinitions() {
+                return *s_fontDefinitions;
+            }
 
         }
 
@@ -996,7 +1068,7 @@ namespace hex {
             };
         }
 
-        void loadFont(const std::fs::path &path, const std::vector<GlyphRange> &glyphRanges, Offset offset, u32 flags, std::optional<u32> defaultSize) {
+        void loadFont(const std::fs::path &path, const std::vector<GlyphRange> &glyphRanges, Offset offset, u32 flags, std::optional<bool> scalable, std::optional<u32> defaultSize) {
             wolv::io::File fontFile(path, wolv::io::File::Mode::Read);
             if (!fontFile.isValid()) {
                 log::error("Failed to load font from file '{}'", wolv::util::toUTF8String(path));
@@ -1009,25 +1081,23 @@ namespace hex {
                 glyphRanges,
                 offset,
                 flags,
+                scalable,
                 defaultSize
             });
         }
 
-        void loadFont(const std::string &name, const std::span<const u8> &data, const std::vector<GlyphRange> &glyphRanges, Offset offset, u32 flags, std::optional<u32> defaultSize) {
+        void loadFont(const std::string &name, const std::span<const u8> &data, const std::vector<GlyphRange> &glyphRanges, Offset offset, u32 flags, std::optional<bool> scalable, std::optional<u32> defaultSize) {
             impl::s_fonts->emplace_back(Font {
                 name,
                 { data.begin(), data.end() },
                 glyphRanges,
                 offset,
                 flags,
+                scalable,
                 defaultSize
             });
         }
 
-        const std::fs::path& getCustomFontPath() {
-            return impl::s_customFontPath;
-        }
-
         float getFontSize() {
             return impl::s_fontSize;
         }
@@ -1036,6 +1106,14 @@ namespace hex {
             return impl::s_fontAtlas;
         }
 
+        void registerFont(const UnlocalizedString &fontName) {
+            (*impl::s_fontDefinitions)[fontName] = nullptr;
+        }
+
+        ImFont* getFont(const UnlocalizedString &fontName) {
+            return (*impl::s_fontDefinitions)[fontName];
+        }
+
         ImFont* Bold() {
             return impl::s_boldFont;
         }
@@ -1044,6 +1122,18 @@ namespace hex {
             return impl::s_italicFont;
         }
 
+        float getDpi() {
+            auto dpi = ImGui::GetCurrentContext()->CurrentDpiScale * 96.0F;
+            return dpi ? dpi : 96.0F;
+        }
+
+        float pixelsToPoints(float pixels) {
+            return pixels * (72.0 / getDpi());
+        }
+
+        float pointsToPixels(float points) {
+            return points / (72.0 / getDpi());
+        }
 
     }
 

lib/libimhex/source/api/layout_manager.cpp

@@ -41,21 +41,27 @@ namespace hex {
         std::ranges::transform(fileName, fileName.begin(), tolower);
         fileName += ".hexlyt";
 
-        std::fs::path layoutPath;
         for (const auto &path : paths::Layouts.write()) {
-            layoutPath = path / fileName;
-        }
+            size_t outSize = 0;
+            const char* iniData = ImGui::SaveIniSettingsToMemory(&outSize);
 
-        if (layoutPath.empty()) {
-            log::error("Failed to save layout '{}'. No writable path found", name);
+            std::fs::path layoutPath = path / fileName;
+            wolv::io::File file = wolv::io::File(layoutPath, wolv::io::File::Mode::Write);
+            if (!file.isValid()) {
+                log::warn("Failed to save layout '{}'. Could not open file '{}', continuing with next path", name, wolv::util::toUTF8String(layoutPath));
+                continue;
+            }
+
+            const size_t written = file.writeBuffer(reinterpret_cast<const u8*>(iniData), outSize);
+            if (written != outSize) {
+                log::warn("Failed to save layout '{}'. Could not write file '{}', continuing with next path", name, wolv::util::toUTF8String(layoutPath));
+                continue;
+            }
+            log::info("Layout '{}' saved to '{}'", name, wolv::util::toUTF8String(layoutPath));
+            LayoutManager::reload();
             return;
         }
-
-        const auto pathString = wolv::util::toUTF8String(layoutPath);
-        ImGui::SaveIniSettingsToDisk(pathString.c_str());
-        log::info("Layout '{}' saved to {}", name, pathString);
-
-        LayoutManager::reload();
+        log::error("Failed to save layout '{}'. No writable path found", name);
     }
 
     std::string LayoutManager::saveToString() {

lib/libimhex/source/api/localization_manager.cpp

@@ -56,18 +56,19 @@ namespace hex {
             }
         }
 
-        void loadLanguage(const std::string &language) {
+        void loadLanguage(std::string language) {
             auto &definitions = ContentRegistry::Language::impl::getLanguageDefinitions();
 
+            const auto& fallbackLanguage = getFallbackLanguage();
             if (!definitions.contains(language))
-                return;
+                language = fallbackLanguage;
 
             s_currStrings->clear();
 
             loadLanguageDefinitions(definitions.at(language));
 
-            const auto& fallbackLanguage = getFallbackLanguage();
-            loadLanguageDefinitions(definitions.at(fallbackLanguage));
+            if (language != fallbackLanguage)
+                loadLanguageDefinitions(definitions.at(fallbackLanguage));
 
             s_selectedLanguage = language;
         }

lib/libimhex/source/api/plugin_manager.cpp

@@ -30,7 +30,11 @@ namespace hex {
 
             return handle;
         #else
-            auto handle = uintptr_t(dlopen(wolv::util::toUTF8String(path).c_str(), RTLD_LAZY));
+            const auto pathString = wolv::util::toUTF8String(path);
+
+            auto handle = uintptr_t(dlopen(pathString.c_str(), RTLD_NOLOAD));
+            if (handle == 0)
+                handle = uintptr_t(dlopen(pathString.c_str(), RTLD_NOW | RTLD_GLOBAL));
 
             if (handle == 0) {
                 log::error("Loading library '{}' failed: {}!", wolv::util::toUTF8String(path.filename()), dlerror());

lib/libimhex/source/api/shortcut_manager.cpp

@@ -1,6 +1,7 @@
 #include <hex/api/shortcut_manager.hpp>
 #include <imgui.h>
 #include <hex/api/content_registry.hpp>
+#include <hex/api/task_manager.hpp>
 #include <hex/helpers/auto_reset.hpp>
 
 #include <hex/ui/view.hpp>
@@ -13,6 +14,7 @@ namespace hex {
         std::atomic<bool> s_paused;
         std::optional<Shortcut> s_prevShortcut;
         bool s_macOSMode = false;
+        AutoReset<std::optional<UnlocalizedString>> s_lastShortcutMainMenu;
 
     }
 
@@ -231,28 +233,66 @@ namespace hex {
         return result;
     }
 
+    KeyEquivalent Shortcut::toKeyEquivalent() const {
+        #if defined(OS_MACOS)
+            if (*this == None)
+                return { };
 
-    void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const std::function<void()> &callback) {
+            KeyEquivalent result = {};
+            result.valid = true;
+
+            for (const auto &key : m_keys) {
+                switch (key.getKeyCode()) {
+                    case CTRL.getKeyCode():
+                        result.ctrl = true;
+                        break;
+                    case SHIFT.getKeyCode():
+                        result.shift = true;
+                        break;
+                    case ALT.getKeyCode():
+                        result.opt = true;
+                        break;
+                    case SUPER.getKeyCode():
+                    case CTRLCMD.getKeyCode():
+                        result.cmd = true;
+                        break;
+                    case CurrentView.getKeyCode(): break;
+                    case AllowWhileTyping.getKeyCode(): break;
+                    default:
+                        macosGetKey(Keys(key.getKeyCode()), &result.key);
+                        break;
+                }
+            }
+
+            return result;
+        #else
+            return { };
+        #endif
+    }
+
+
+
+    void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const std::function<void()> &callback, const EnabledCallback &enabledCallback) {
         log::debug("Adding global shortcut {} for {}", shortcut.toString(), unlocalizedName.back().get());
-        auto [it, inserted] = s_globalShortcuts->insert({ shortcut, { shortcut, unlocalizedName, callback } });
+        auto [it, inserted] = s_globalShortcuts->insert({ shortcut, { shortcut, unlocalizedName, callback, enabledCallback } });
         if (!inserted) log::error("Failed to add shortcut!");
     }
 
-    void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const std::function<void()> &callback) {
+    void ShortcutManager::addGlobalShortcut(const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const std::function<void()> &callback, const EnabledCallback &enabledCallback) {
         log::debug("Adding global shortcut {} for {}", shortcut.toString(), unlocalizedName.get());
-        auto [it, inserted] = s_globalShortcuts->insert({ shortcut, { shortcut, { unlocalizedName }, callback } });
+        auto [it, inserted] = s_globalShortcuts->insert({ shortcut, { shortcut, { unlocalizedName }, callback, enabledCallback } });
         if (!inserted) log::error("Failed to add shortcut!");
     }
 
-    void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const std::function<void()> &callback) {
+    void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const std::vector<UnlocalizedString> &unlocalizedName, const std::function<void()> &callback, const EnabledCallback &enabledCallback) {
         log::debug("Adding shortcut {} for {}", shortcut.toString(), unlocalizedName.back().get());
-        auto [it, inserted] = view->m_shortcuts.insert({ shortcut + CurrentView, { shortcut, unlocalizedName, callback } });
+        auto [it, inserted] = view->m_shortcuts.insert({ shortcut + CurrentView, { shortcut, unlocalizedName, callback, enabledCallback } });
         if (!inserted) log::error("Failed to add shortcut!");
     }
 
-    void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const std::function<void()> &callback) {
+    void ShortcutManager::addShortcut(View *view, const Shortcut &shortcut, const UnlocalizedString &unlocalizedName, const std::function<void()> &callback, const EnabledCallback &enabledCallback) {
         log::debug("Adding shortcut {} for {}", shortcut.toString(), unlocalizedName.get());
-        auto [it, inserted] = view->m_shortcuts.insert({ shortcut + CurrentView, { shortcut, { unlocalizedName }, callback } });
+        auto [it, inserted] = view->m_shortcuts.insert({ shortcut + CurrentView, { shortcut, { unlocalizedName }, callback, enabledCallback } });
         if (!inserted) log::error("Failed to add shortcut!");
     }
 
@@ -269,24 +309,49 @@ namespace hex {
             pressedShortcut += s_macOSMode ? CTRLCMD : SUPER;
         if (focused)
             pressedShortcut += CurrentView;
-        if (ImGui::GetIO().WantTextInput)
-            pressedShortcut += AllowWhileTyping;
 
-        pressedShortcut += static_cast<Keys>(keyCode);
+        pressedShortcut += scanCodeToKey(keyCode);
 
         return pressedShortcut;
     }
 
-    static void processShortcut(const Shortcut &shortcut, const std::map<Shortcut, ShortcutManager::ShortcutEntry> &shortcuts) {
-        if (s_paused) return;
+    static bool processShortcut(Shortcut shortcut, const std::map<Shortcut, ShortcutManager::ShortcutEntry> &shortcuts) {
+        if (s_paused)
+            return true;
 
         if (ImGui::IsPopupOpen(ImGuiID(0), ImGuiPopupFlags_AnyPopupId))
-            return;
+            return true;
 
-        if (auto it = shortcuts.find(shortcut); it != shortcuts.end()) {
-            const auto &[foundShortcut, entry] = *it;
-            entry.callback();
+        const bool currentlyTyping = ImGui::GetIO().WantTextInput;
+
+        auto it = shortcuts.find(shortcut + AllowWhileTyping);
+        if (!currentlyTyping && it == shortcuts.end()) {
+            if (it == shortcuts.end())
+                it = shortcuts.find(shortcut);
         }
+
+        if (it != shortcuts.end()) {
+            const auto &[foundShortcut, entry] = *it;
+
+            if (entry.enabledCallback()) {
+                entry.callback();
+
+                if (!entry.unlocalizedName.empty()) {
+                    s_lastShortcutMainMenu = entry.unlocalizedName.front();
+                }
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool ShortcutManager::runShortcut(const Shortcut &shortcut, const View *view) {
+        if (view == nullptr)
+            return processShortcut(shortcut, s_globalShortcuts);
+        else
+            return processShortcut(shortcut, view->m_shortcuts);
     }
 
     void ShortcutManager::process(const View *currentView, bool ctrl, bool alt, bool shift, bool super, bool focused, u32 keyCode) {
@@ -294,7 +359,7 @@ namespace hex {
         if (keyCode != 0)
             s_prevShortcut = Shortcut(pressedShortcut.getKeys());
 
-        processShortcut(pressedShortcut, currentView->m_shortcuts);
+        runShortcut(pressedShortcut, currentView);
     }
 
     void ShortcutManager::processGlobals(bool ctrl, bool alt, bool shift, bool super, u32 keyCode) {
@@ -302,9 +367,18 @@ namespace hex {
         if (keyCode != 0)
             s_prevShortcut = Shortcut(pressedShortcut.getKeys());
 
-        processShortcut(pressedShortcut, s_globalShortcuts);
+        runShortcut(pressedShortcut);
     }
 
+    std::optional<UnlocalizedString> ShortcutManager::getLastActivatedMenu() {
+        return *s_lastShortcutMainMenu;
+    }
+
+    void ShortcutManager::resetLastActivatedMenu() {
+        s_lastShortcutMainMenu->reset();
+    }
+
+
     void ShortcutManager::clearShortcuts() {
         s_globalShortcuts->clear();
     }