ImHex

https://github.com/werwolv/imhex
Admin
ImHex is a powerful hex editor designed for reverse engineers and programmers, offering advanced...
Tokens:36,105
Snippets:371
Trust Score:10
License:GPL-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install ImHex via Snap

Source: https://github.com/werwolv/imhex/blob/master/INSTALL.md

Install the application using the snap package manager.

```bash
snap install ./imhex-*.snap
```

--------------------------------

### Build imnodes examples with CMake

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imnodes/README.md

Commands to initialize submodules and build the example projects using CMake and vcpkg.

```bash
# Initialize the vcpkg submodule
$ git submodule update --init
# Run the generation step and build
$ cmake -B build-release/ -S . -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=vcpkg/scripts/buildsystems/vcpkg.cmake
$ cmake --build build-release -- -j
```

--------------------------------

### Install library components

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/nlohmann_json/CMakeLists.txt

Installs headers, config files, Natvis files, and exports targets if JSON_Install is enabled.

```cmake
if(JSON_Install)
    install(
        DIRECTORY ${NLOHMANN_JSON_INCLUDE_BUILD_DIR}
        DESTINATION ${NLOHMANN_JSON_INCLUDE_INSTALL_DIR}
    )
    install(
        FILES ${NLOHMANN_JSON_CMAKE_PROJECT_CONFIG_FILE} ${NLOHMANN_JSON_CMAKE_VERSION_CONFIG_FILE}
        DESTINATION ${NLOHMANN_JSON_CONFIG_INSTALL_DIR}
    )
    if (NLOHMANN_ADD_NATVIS)
        install(
            FILES ${NLOHMANN_NATVIS_FILE}
            DESTINATION .
    )
    endif()
    export(
        TARGETS ${NLOHMANN_JSON_TARGET_NAME}
        NAMESPACE ${PROJECT_NAME}::
        FILE ${NLOHMANN_JSON_CMAKE_PROJECT_TARGETS_FILE}
    )
    install(
        TARGETS ${NLOHMANN_JSON_TARGET_NAME}
        EXPORT ${NLOHMANN_JSON_TARGETS_EXPORT_NAME}
        INCLUDES DESTINATION ${NLOHMANN_JSON_INCLUDE_INSTALL_DIR}
    )
    install(
        EXPORT ${NLOHMANN_JSON_TARGETS_EXPORT_NAME}
        NAMESPACE ${PROJECT_NAME}::
        DESTINATION ${NLOHMANN_JSON_CONFIG_INSTALL_DIR}
    )
    install(
        FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
        DESTINATION ${NLOHMANN_JSON_PKGCONFIG_INSTALL_DIR}
    )
endif()
```

--------------------------------

### Install ImHex via Flatpak

Source: https://github.com/werwolv/imhex/blob/master/INSTALL.md

Install from Flathub or from a local file.

```bash
flatpak install flathub net.werwolv.ImHex
# or install the file directly
flatpak install ./imhex-*.flatpak
```

--------------------------------

### Define Project Paths and Configuration

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/nlohmann_json/CMakeLists.txt

Sets up installation directories and configuration file paths for the project.

```cmake
include(GNUInstallDirs)

set(NLOHMANN_JSON_TARGET_NAME               ${PROJECT_NAME})
set(NLOHMANN_JSON_CONFIG_INSTALL_DIR        "${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME}" CACHE INTERNAL "")
set(NLOHMANN_JSON_INCLUDE_INSTALL_DIR       "${CMAKE_INSTALL_INCLUDEDIR}")
set(NLOHMANN_JSON_TARGETS_EXPORT_NAME       "${PROJECT_NAME}Targets")
set(NLOHMANN_JSON_CMAKE_CONFIG_TEMPLATE     "cmake/config.cmake.in")
set(NLOHMANN_JSON_CMAKE_CONFIG_DIR          "${CMAKE_CURRENT_BINARY_DIR}")
set(NLOHMANN_JSON_CMAKE_VERSION_CONFIG_FILE "${NLOHMANN_JSON_CMAKE_CONFIG_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
set(NLOHMANN_JSON_CMAKE_PROJECT_CONFIG_FILE "${NLOHMANN_JSON_CMAKE_CONFIG_DIR}/${PROJECT_NAME}Config.cmake")
set(NLOHMANN_JSON_CMAKE_PROJECT_TARGETS_FILE "${NLOHMANN_JSON_CMAKE_CONFIG_DIR}/${PROJECT_NAME}Targets.cmake")
set(NLOHMANN_JSON_PKGCONFIG_INSTALL_DIR     "${CMAKE_INSTALL_DATADIR}/pkgconfig")
```

--------------------------------

### Install ImPlot with vcpkg

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/implot/README.md

Commands to clone vcpkg and install the ImPlot library.

```bash
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
./vcpkg install implot
```

--------------------------------

### Platform-Specific Linking and Setup

Source: https://github.com/werwolv/imhex/blob/master/main/gui/CMakeLists.txt

Handles linking of libraries and platform-specific setup for Windows, macOS, and Linux.

```cmake
target_link_libraries(main PRIVATE libromfs-imhex libimhex libwolv ${LIBBACKTRACE_LIBRARIES})
if (WIN32)
    target_link_libraries(main PRIVATE usp10 wsock32 ws2_32 Dwmapi.lib Winmm.lib)

    if (MSVC)
        target_link_options(main PRIVATE /MANIFEST:NO /ENTRY:mainCRTStartup)
    else()
        target_link_libraries(main PRIVATE pthread)
    endif()
else ()
    target_link_libraries(main PRIVATE pthread)

    if (APPLE)
        set_target_properties(main PROPERTIES
                OUTPUT_NAME "${MACOSX_BUNDLE_BUNDLE_NAME}"
        )
        if (IMHEX_MACOS_CREATE_BUNDLE)
            add_custom_command(TARGET main PRE_BUILD
                    COMMAND ${CMAKE_COMMAND} -E make_directory "${IMHEX_BUNDLE_PATH}/Contents/MacOS/plugins"
            )
            add_custom_command(TARGET main PRE_BUILD
                    COMMAND ${CMAKE_COMMAND} -E make_directory "${IMHEX_BUNDLE_PATH}/Contents/Resources"
            )
            add_custom_command(TARGET main POST_BUILD
                COMMAND ${CMAKE_COMMAND} -E copy ${IMHEX_ICON} $<TARGET_FILE_DIR:main>/../Resources/${MACOSX_BUNDLE_ICON_FILE}
            )
        endif()
    else()
        find_package(Fontconfig)
        if (TARGET Fontconfig::Fontconfig)
            message(STATUS "Using Fontconfig version: ${Fontconfig_VERSION}")
            target_link_libraries(main PRIVATE Fontconfig::Fontconfig)
            target_compile_definitions(main PRIVATE IMHEX_HAS_FONTCONFIG)
        endif ()
    endif ()
endif ()
```

--------------------------------

### Install Dependencies

Source: https://github.com/werwolv/imhex/blob/master/dist/compiling/macos.md

Install required build dependencies using Homebrew.

```bash
brew bundle --file dist/macOS/Brewfile
```

--------------------------------

### Install ImHex DEB Package

Source: https://github.com/werwolv/imhex/blob/master/INSTALL.md

Install the Debian package on Ubuntu or compatible systems.

```bash
sudo apt install ./imhex-*.deb
```

--------------------------------

### Install ImHex Arch Linux Package

Source: https://github.com/werwolv/imhex/blob/master/INSTALL.md

Install the Arch Linux package using pacman.

```bash
sudo pacman -U imhex-*.pkg.tar.zst
```

--------------------------------

### Set installation and library naming conventions

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/yara/CMakeLists.txt

Includes standard GNU install directories and removes the static library prefix.

```cmake
include(GNUInstallDirs)

set(CMAKE_STATIC_LIBRARY_PREFIX "")
```

--------------------------------

### Define a Plugin Setup Block

Source: https://github.com/werwolv/imhex/wiki/Plugins-Development-Guide

Every plugin must include plugin.hpp and define an IMHEX_PLUGIN_SETUP block to register features upon loading.

```cpp
#include <plugin.hpp>   // Needed for plugin functions

// Register your features here
IMHEX_PLUGIN_SETUP("Plugin Name", "Plugin Author", "Plugin Description") {
   // ...
}
```

--------------------------------

### Build the ImHex SDK

Source: https://github.com/werwolv/imhex/blob/master/README.md

Commands to compile ImHex with the SDK bundle option and install it to a local directory.

```bash
cmake -G Ninja -DIMHEX_BUNDLE_PLUGIN_SDK=ON -B build
cd build
DESTDIR=install ninja install
```

--------------------------------

### Configure Packaging and Subdirectories

Source: https://github.com/werwolv/imhex/blob/master/CMakeLists.txt

Configures installation targets, adds project subdirectories, and handles packaging resources.

```cmake
# Configure packaging and install targets
configurePackingResources()
setUninstallTarget()
addBundledLibraries()

add_subdirectory(lib/libimhex)
add_subdirectory(main)

# Add unit tests
if (IMHEX_ENABLE_UNIT_TESTS)
    enable_testing()

    if (NOT TARGET unit_tests)
        add_custom_target(unit_tests)
    endif ()

    add_subdirectory(tests)
endif ()

addPluginDirectories()
add_subdirectory(lib/trace)

# Configure more resources that will be added to the install package
if (IMHEX_BUNDLE_PLUGIN_SDK)
    generateSDKDirectory()
endif()

# Handle package generation
createPackage()
```

--------------------------------

### Install ImHex via Windows Package Managers

Source: https://github.com/werwolv/imhex/blob/master/INSTALL.md

Commands for installing ImHex using Chocolatey or Winget.

```bash
choco install imhex
```

```bash
winget install WerWolv.ImHex
```

--------------------------------

### Install ImHex via Linux Package Managers

Source: https://github.com/werwolv/imhex/blob/master/INSTALL.md

Commands for installing ImHex using AUR helpers or dnf.

```bash
yay -S imhex-bin
```

```bash
yay -S imhex
```

```bash
dnf install imhex
```

```bash
flatpak install flathub net.werwolv.ImHex
```

--------------------------------

### Install ImHex RPM Package

Source: https://github.com/werwolv/imhex/blob/master/INSTALL.md

Install the RPM package on Fedora, RHEL, or AlmaLinux.

```bash
sudo dnf install ./imhex-*.rpm
```

--------------------------------

### Add Custom Interface Entries

Source: https://github.com/werwolv/imhex/wiki/Plugins-Development-Guide

Extend the Welcome screen or footer by registering UI callbacks within the plugin setup.

```cpp
IMHEX_PLUGIN_SETUP("Custom interface", "WerWolv", "Plugin that adds new information to various interfaces") {

    ContentRegistry::Interface::addWelcomeScreenEntry([] {
        ImGui::TextUnformatted("Hello Welcome Screen");
    });

    ContentRegistry::Interface::addFooterItem([] {
        if (ImGui::Button("Footer Button")) {
            // ...
        }
    });

}
```

--------------------------------

### Install ImHex dependencies

Source: https://github.com/werwolv/imhex/blob/master/dist/compiling/windows.md

Execute the provided shell script to install all required build dependencies within the MSYS2 environment.

```bash
./ImHex/dist/get_deps_msys2.sh
```

--------------------------------

### Configure Include Directories

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/nlohmann_json/CMakeLists.txt

Sets the interface include directories for build and install interfaces.

```cmake
target_include_directories(
    ${NLOHMANN_JSON_TARGET_NAME}
    ${NLOHMANN_JSON_SYSTEM_INCLUDE} INTERFACE
    $<BUILD_INTERFACE:${NLOHMANN_JSON_INCLUDE_BUILD_DIR}>
    $<INSTALL_INTERFACE:${NLOHMANN_JSON_INCLUDE_INSTALL_DIR}>
)
```

--------------------------------

### Perform common string operations

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imgui_test_engine/include/thirdparty/Str/README.md

Examples of setting, appending, and referencing string data using Str256.

```cpp
Str256 s;
s.set("hello sailor");                   // set (copy)
s.setf("%s/%s.tmp", folder, filename);   // set (w/format)
s.append("hello");                       // append. cost a length() calculation!
s.appendf("hello %d", 42);               // append (w/format). cost a length() calculation!
s.set_ref("Hey!");                       // set (literal/reference, just copy pointer, no tracking)
```

--------------------------------

### Define Custom ImNodes Configuration

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imnodes/README.md

Example of an imnodes_config.h file to override callback types, useful for language bindings.

```cpp
#pragma once

#include <pybind11/functional.h>

namespace pybind11 {

inline bool PyWrapper_Check(PyObject *o) { return true; }

class wrapper : public object {
public:
    PYBIND11_OBJECT_DEFAULT(wrapper, object, PyWrapper_Check)
    wrapper(void* x) { m_ptr = (PyObject*)x; }
    explicit operator bool() const { return m_ptr != nullptr && m_ptr != Py_None; }
};

} //namespace pybind11

namespace py = pybind11;

#define ImNodesMiniMapNodeHoveringCallback py::wrapper

#define ImNodesMiniMapNodeHoveringCallbackUserData py::wrapper
```

--------------------------------

### Configure Build Options

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/nlohmann_json/CMakeLists.txt

Sets various build options for the library, such as diagnostic messages, implicit conversions, and installation targets.

```cmake
if(${MAIN_PROJECT} AND (${CMAKE_VERSION} VERSION_EQUAL 3.13 OR ${CMAKE_VERSION} VERSION_GREATER 3.13))
    set(JSON_BuildTests_INIT ON)
else()
    set(JSON_BuildTests_INIT OFF)
endif()
option(JSON_BuildTests                     "Build the unit tests when BUILD_TESTING is enabled." ${JSON_BuildTests_INIT})
option(JSON_CI                             "Enable CI build targets." OFF)
option(JSON_Diagnostics                    "Use extended diagnostic messages." OFF)
option(JSON_GlobalUDLs                     "Place use-defined string literals in the global namespace." ON)
option(JSON_ImplicitConversions            "Enable implicit conversions." ON)
option(JSON_DisableEnumSerialization       "Disable default integer enum serialization." OFF)
option(JSON_LegacyDiscardedValueComparison "Enable legacy discarded value comparison." OFF)
option(JSON_Install                        "Install CMake targets during install step." ${MAIN_PROJECT})
option(JSON_MultipleHeaders                "Use non-amalgamated version of the library." ON)
option(JSON_SystemInclude                  "Include as system headers (skip for clang-tidy)." OFF)

if (JSON_CI)
    include(ci)
endif ()
```

--------------------------------

### Set global libimhex dependencies and properties

Source: https://github.com/werwolv/imhex/blob/master/lib/libimhex/CMakeLists.txt

Configures general dependencies, optimization flags, and installation rules for the libimhex target.

```cmake
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)

add_dependencies(imhex_all libimhex)

install(FILES "$<TARGET_FILE:libimhex>" DESTINATION "${CMAKE_INSTALL_LIBDIR}" PERMISSIONS ${LIBRARY_PERMISSIONS})
set_target_properties(libimhex PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
set_target_properties(libimhex PROPERTIES PREFIX "")
```

--------------------------------

### Configure ImGui Backend Library

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/backend/CMakeLists.txt

Initializes the imgui_backend object library and sets up include directories and basic dependencies.

```cmake
cmake_minimum_required(VERSION 3.16)
# https://github.com/ocornut/imgui backends with custom modifications made to the OpenGL 3 and GLFW backends
project(imgui_backend)

set(CMAKE_CXX_STANDARD 23)

if (NOT IMHEX_EXTERNAL_PLUGIN_BUILD)
    add_library(imgui_backend OBJECT
        source/imgui_impl_opengl3.cpp
    )

    target_include_directories(imgui_backend PUBLIC
        include
    )

    target_link_libraries(imgui_backend PRIVATE imgui_includes)

    find_package(OpenGL REQUIRED)
    find_package(Freetype REQUIRED)
```

--------------------------------

### Configure Build Environment and Dependencies

Source: https://github.com/werwolv/imhex/blob/master/main/gui/CMakeLists.txt

Sets up include directories, compiler flags, and external dependencies like libromfs.

```cmake
target_include_directories(main PUBLIC include)
addCppCheck(main)
setupCompilerFlags(main)
setupCompilerFlags(libimhex)

set(LIBROMFS_RESOURCE_LOCATION ${CMAKE_CURRENT_SOURCE_DIR}/romfs)
set(LIBROMFS_PROJECT_NAME imhex)
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../lib/external/libromfs ${CMAKE_CURRENT_BINARY_DIR}/main/gui/libromfs EXCLUDE_FROM_ALL)
add_dependencies(imhex_all main)
```

--------------------------------

### Initialize ImHex SDK Project

Source: https://github.com/werwolv/imhex/blob/master/cmake/sdk/CMakeLists.txt

Sets up the project requirements, module paths, and includes essential build helpers.

```cmake
cmake_minimum_required(VERSION 3.20)
project(ImHexSDK)

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
set(CMAKE_POSITION_INDEPENDENT_CODE ON CACHE BOOL "" FORCE)
include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/build_helpers.cmake")

set(IMHEX_BASE_FOLDER ${CMAKE_CURRENT_SOURCE_DIR} PARENT_SCOPE)
include(ImHexPlugin)
```

--------------------------------

### Initialize and Destroy ImNodes Context

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imnodes/README.md

Initialize the library alongside Dear ImGui and ensure proper cleanup.

```cpp
ImGui::CreateContext();
ImNodes::CreateContext();

// elsewhere in the code...
ImNodes::DestroyContext();
ImGui::DestroyContext();
```

--------------------------------

### Initialize Build Targets and Environment

Source: https://github.com/werwolv/imhex/blob/master/CMakeLists.txt

Initializes custom targets, verifies compiler compatibility, and detects OS and bundled plugins.

```cmake
# Add ImHex sources
add_custom_target(imhex_all ALL)

# Make sure project is configured correctly
setDefaultBuiltTypeIfUnset()
detectBadClone()
verifyCompiler()

detectBundledPlugins()

# Add various defines
detectOS()
addDefines()
```

--------------------------------

### Initialize Str with different buffer configurations

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imgui_test_engine/include/thirdparty/Str/README.md

Demonstrates how to declare Str instances with varying local buffer sizes to optimize heap usage.

```cpp
Str s = "hey";   // use heap
```

```cpp
Str16 s = "filename.h"; // copy into local buffer
Str16 s = "long_filename_not_very_long_but_longer_than_expected.h";   // use heap
```

```cpp
Str256 s = "long_filename_not_very_long_but_longer_than_expected.h";  // copy into local buffer
```

--------------------------------

### Configure External Dependencies

Source: https://github.com/werwolv/imhex/blob/master/cmake/sdk/CMakeLists.txt

Sets up third-party libraries like fmt, nlohmann_json, and boost.

```cmake
set(IMHEX_EXTERNAL_PLUGIN_BUILD ON PARENT_SCOPE)
set(IMHEX_EXTERNAL_PLUGIN_BUILD ON)
add_custom_target(imhex_all)

add_subdirectory(lib/third_party/imgui EXCLUDE_FROM_ALL)

set(FMT_INSTALL OFF CACHE BOOL "" FORCE)
add_subdirectory_if_exists(lib/third_party/fmt)
set(FMT_LIBRARIES fmt::fmt-header-only PARENT_SCOPE)
set(FMT_LIBRARIES fmt::fmt-header-only)

add_subdirectory_if_exists(lib/third_party/nlohmann_json)
set(NLOHMANN_JSON_LIBRARIES nlohmann_json PARENT_SCOPE)
set(NLOHMANN_JSON_LIBRARIES nlohmann_json)

add_subdirectory_if_exists(lib/third_party/boost)
set(BOOST_LIBRARIES boost::regex PARENT_SCOPE)
set(BOOST_LIBRARIES boost::regex)
```

--------------------------------

### Invoke Built-in Functions

Source: https://github.com/werwolv/imhex/wiki/Pattern-Language-Guide

Example of using the findSequence function to locate data and assign it to a struct header.

```cpp
ElfHeader header @ findSequence(0, 0x7F, 'E', 'L', 'F');
```

--------------------------------

### Finalize library configuration

Source: https://github.com/werwolv/imhex/blob/master/lib/libimhex/CMakeLists.txt

Sets up compiler flags, export headers, and include directories.

```cmake
enableUnityBuild(libimhex)
setupCompilerFlags(libimhex)

include(GenerateExportHeader)
generate_export_header(libimhex)

target_include_directories(libimhex ${LIBIMHEX_LIBRARY_TYPE} include ${XDGPP_INCLUDE_DIRS} ${LLVM_INCLUDE_DIRS} ${FMT_INCLUDE_DIRS})
```

--------------------------------

### Advanced UI Window and Widget Layout

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imgui/README.md

Shows how to create a window with a menu bar, color editors, data plotting, and scrolling regions.

```cpp
// Create a window called "My First Tool", with a menu bar.
ImGui::Begin("My First Tool", &my_tool_active, ImGuiWindowFlags_MenuBar);
if (ImGui::BeginMenuBar())
{
    if (ImGui::BeginMenu("File"))
    {
        if (ImGui::MenuItem("Open..", "Ctrl+O")) { /* Do stuff */ }
        if (ImGui::MenuItem("Save", "Ctrl+S"))   { /* Do stuff */ }
        if (ImGui::MenuItem("Close", "Ctrl+W"))  { my_tool_active = false; }
        ImGui::EndMenu();
    }
    ImGui::EndMenuBar();
}

// Edit a color stored as 4 floats
ImGui::ColorEdit4("Color", my_color);

// Generate samples and plot them
float samples[100];
for (int n = 0; n < 100; n++)
    samples[n] = sinf(n * 0.2f + ImGui::GetTime() * 1.5f);
ImGui::PlotLines("Samples", samples, 100);

// Display contents in a scrolling region
ImGui::TextColored(ImVec4(1,1,0,1), "Important Stuff");
ImGui::BeginChild("Scrolling");
for (int n = 0; n < 50; n++)
    ImGui::Text("%04d: Some text", n);
ImGui::EndChild();
ImGui::End();
```

--------------------------------

### Define and invoke add_dotnet_assembly function

Source: https://github.com/werwolv/imhex/blob/master/plugins/script_loader/support/dotnet/CMakeLists.txt

Defines a custom CMake function to build .NET projects and registers an assembly for installation.

```cmake
project(dotnet_assemblies)

function(add_dotnet_assembly name)
    set(OUTPUT_DLL ${CMAKE_CURRENT_BINARY_DIR}/../../${name}.dll)
    set(OUTPUT_RUNTIMECONFIG ${CMAKE_CURRENT_BINARY_DIR}/../../${name}.runtimeconfig.json)

    file(GLOB_RECURSE sources ${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cs)
    add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/../../${name}.dll
        COMMAND ${DOTNET_EXECUTABLE} build ${CMAKE_CURRENT_SOURCE_DIR}/${name}/${name}.csproj -nologo -consoleLoggerParameters:NoSummary -verbosity:quiet -c Release -o ${CMAKE_CURRENT_BINARY_DIR}/../..
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${name}/${name}.csproj ${sources}
        COMMENT "Building ${name}.dll"
    )

    add_custom_target(${name} ALL DEPENDS ${OUTPUT_DLL})

    install(FILES
                ${OUTPUT_DLL}
                ${OUTPUT_RUNTIMECONFIG}
            DESTINATION
                ${PLUGINS_INSTALL_LOCATION}
    )
endfunction()

add_dotnet_assembly(AssemblyLoader)
```

--------------------------------

### Define Test Suite and Dependencies

Source: https://github.com/werwolv/imhex/blob/master/tests/helpers/CMakeLists.txt

Sets up the project, defines the list of available tests, and configures the executable with necessary dependencies.

```cmake
cmake_minimum_required(VERSION 3.16)

project(helpers_test)
set(TEST_CATEGORY Helpers)

# Add new tests here #
set(AVAILABLE_TESTS
    # Common
        TestSucceeding
        TestFailing
        TestProvider_read
        TestProvider_write
        EncodingLineStartAddressCache

    # File
        FileAccess
        FileBackedProviderData

    # Utils
        ExtractBits
)

if (NOT IMHEX_OFFLINE_BUILD)
    set(AVAILABLE_TESTS ${AVAILABLE_TESTS}
        # Net
        StoreAPI
        TipsAPI
        ContentAPI
    )
endif ()


add_executable(${PROJECT_NAME}
        source/common.cpp
        source/encoding_line_cache.cpp
        source/file.cpp
        source/net.cpp
        source/utils.cpp
)


# ---- No need to change anything from here downwards unless you know what you're doing ---- #

target_include_directories(${PROJECT_NAME} PRIVATE include)
target_link_libraries(${PROJECT_NAME} PRIVATE libimhex tests_common ${FMT_LIBRARIES})

set_target_properties(${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${IMHEX_MAIN_OUTPUT_DIRECTORY})

foreach (test IN LISTS AVAILABLE_TESTS)
    add_test(NAME "${TEST_CATEGORY}/${test}" COMMAND ${PROJECT_NAME} "${test}" WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endforeach ()
add_dependencies(unit_tests ${PROJECT_NAME})
```

--------------------------------

### Platform-Specific Linking

Source: https://github.com/werwolv/imhex/blob/master/plugins/builtin/CMakeLists.txt

Links the setupapi library when building on Windows.

```cmake
if (WIN32)
    target_link_libraries(builtin PRIVATE setupapi)
endif ()
```

--------------------------------

### Create a new language file

Source: https://github.com/werwolv/imhex/blob/master/CONTRIBUTING.md

Use this command to initialize a new language file using the ISO 639-1 code.

```bash
python3 dist/langtool.py create plugins/builtin/romfs/lang <iso_code>
```

--------------------------------

### Create a Node Editor Workspace

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imnodes/README.md

Instantiate the node editor within a standard Dear ImGui window.

```cpp
ImGui::Begin("node editor");

ImNodes::BeginNodeEditor();
ImNodes::EndNodeEditor();

ImGui::End();
```

--------------------------------

### Write a tar archive in C

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/microtar/README.md

Demonstrates creating an archive, writing file headers and data, and finalizing the archive.

```c
mtar_t tar;
const char *str1 = "Hello world";
const char *str2 = "Goodbye world";

/* Open archive for writing */
mtar_open(&tar, "test.tar", "w");

/* Write strings to files `test1.txt` and `test2.txt` */
mtar_write_file_header(&tar, "test1.txt", strlen(str1));
mtar_write_data(&tar, str1, strlen(str1));
mtar_write_file_header(&tar, "test2.txt", strlen(str2));
mtar_write_data(&tar, str2, strlen(str2));

/* Finalize -- this needs to be the last thing done before closing */
mtar_finalize(&tar);

/* Close archive */
mtar_close(&tar);
```

--------------------------------

### Define include directories and link libraries

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/yara/CMakeLists.txt

Configures include paths and links necessary dependencies like mbedtls and magic for the libyara target.

```cmake
target_include_directories(
        libyara
        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/yara> $<BUILD_INTERFACE:${LIBYARA_SOURCE_PATH}/include>
        PRIVATE ${LIBYARA_SOURCE_PATH} ${MBEDTLS_INCLUDE_DIR}
)

target_link_directories(libyara PRIVATE ${MBEDTLS_LIBRARY_DIR})

if (UNIX)
    target_link_libraries(libyara PRIVATE magic ${MBEDTLS_LIBRARIES} pthread)
else ()
    target_link_libraries(libyara PRIVATE magic ${MBEDTLS_LIBRARIES})
endif ()
```

--------------------------------

### Basic ImPlot Implementation

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/implot/README.md

Demonstrates the standard BeginPlot/EndPlot workflow for rendering multiple plot types within an ImGui window.

```cpp
int   bar_data[11] = ...;
float x_data[1000] = ...;
float y_data[1000] = ...;

ImGui::Begin("My Window");
if (ImPlot::BeginPlot("My Plot")) {
    ImPlot::PlotBars("My Bar Plot", bar_data, 11);
    ImPlot::PlotLine("My Line Plot", x_data, y_data, 1000);
    ...
    ImPlot::EndPlot();
}
ImGui::End();
```

--------------------------------

### Build ImHex with mingw32-make

Source: https://github.com/werwolv/imhex/blob/master/dist/compiling/windows.md

Use this alternative command for systems with low RAM to control the number of parallel jobs.

```bash
mingw32-make -j N install
```

--------------------------------

### Define main-forwarder executable and properties

Source: https://github.com/werwolv/imhex/blob/master/main/forwarder/CMakeLists.txt

Configures the executable target, links required libraries, and sets output directory properties.

```cmake
project(main-forwarder)

add_executable(main-forwarder
        source/main.cpp
        ${IMHEX_ICON}
)

target_link_libraries(main-forwarder PRIVATE wolv::io ${FMT_LIBRARIES})
add_dependencies(imhex_all main-forwarder)
set_target_properties(main-forwarder PROPERTIES
        OUTPUT_NAME "imhex"
        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/../..
)
```

--------------------------------

### Basic UI Widget Usage

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imgui/README.md

Demonstrates common UI elements like text, buttons, input fields, and sliders that can be called from anywhere in the program loop.

```cpp
ImGui::Text("Hello, world %d", 123);
if (ImGui::Button("Save"))
    MySaveFunction();
ImGui::InputText("string", buf, IM_ARRAYSIZE(buf));
ImGui::SliderFloat("float", &f, 0.0f, 1.0f);
```

--------------------------------

### Clone ImHex Repository

Source: https://github.com/werwolv/imhex/blob/master/dist/compiling/macos.md

Initial step to download the source code and submodules.

```bash
git clone https://github.com/WerWolv/ImHex --recurse-submodules
```

--------------------------------

### Build ImHex

Source: https://github.com/werwolv/imhex/blob/master/dist/compiling/macos.md

Commands to configure the build environment with LLVM clang and compile the project using Ninja.

```bash
cd ImHex
mkdir -p build
cd build
CC=$(brew --prefix llvm)/bin/clang        \
CXX=$(brew --prefix llvm)/bin/clang++     \
OBJC=$(brew --prefix llvm)/bin/clang      \
OBJCXX=$(brew --prefix llvm)/bin/clang++  \
cmake -G "Ninja"                          \
  -DCMAKE_BUILD_TYPE=Release              \
  -DCMAKE_INSTALL_PREFIX="./install"      \
  -DIMHEX_GENERATE_PACKAGE=ON             \
  ..
ninja install
```

--------------------------------

### Configure ImHex Project Build

Source: https://github.com/werwolv/imhex/blob/master/CMakeLists.txt

Sets up the core project environment, including C++ standards, compiler flags, and project metadata.

```cmake
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")

# Setup project
loadVersion(IMHEX_VERSION IMHEX_VERSION_PLAIN)
setVariableInParent(IMHEX_VERSION ${IMHEX_VERSION})

configureCMake()
project(ImHex
        LANGUAGES       C CXX
        VERSION         ${IMHEX_VERSION_PLAIN}
        DESCRIPTION     "The ImHex Hex Editor"
        HOMEPAGE_URL    "https://imhex.werwolv.net"
)
configureProject()
```

--------------------------------

### Apply build definitions

Source: https://github.com/werwolv/imhex/blob/master/lib/libimhex/CMakeLists.txt

Injects versioning and build information into the source code.

```cmake
if (GIT_COMMIT_HASH_LONG STREQUAL "" OR GIT_BRANCH STREQUAL "")
    message(WARNING "Failed to to determine commit hash/branch")
else()
    addDefineToSource(source/api/imhex_api.cpp "GIT_COMMIT_HASH_LONG=\"${GIT_COMMIT_HASH_LONG}\"")
    addDefineToSource(source/api/imhex_api.cpp "GIT_BRANCH=\"${GIT_BRANCH}\"")
endif ()

addDefineToSource(source/api/imhex_api.cpp "IMHEX_VERSION=\"${IMHEX_VERSION_STRING}\"")

string(TIMESTAMP IMHEX_BUILD_DATE UTC)
addDefineToSource(source/api/imhex_api.cpp "IMHEX_BUILD_DATE=\"${IMHEX_BUILD_DATE}\"")
```

--------------------------------

### Run ImHex AppImage on Linux

Source: https://github.com/werwolv/imhex/blob/master/INSTALL.md

Make the AppImage file executable before running it.

```bash
chmod +x imhex-*.AppImage
./imhex-*.AppImage
```

--------------------------------

### Register a Custom View

Source: https://github.com/werwolv/imhex/wiki/Plugins-Development-Guide

Create a custom window by inheriting from hex::View and registering it via ContentRegistry::Views::add.

```cpp
#include <plugin.hpp>

class ViewCustom : public View {
public:
    ViewCustom() : hex::View("Custom") {}
    ~ViewCustom() override {}

    void drawContent() override {
        // Call into ImGui here to draw your view
    }

    void drawMenu() override {
        // Create new menu entries here
    }
};

IMHEX_PLUGIN_SETUP("Custom View", "WerWolv", "Plugin that adds a new view") {
    // Add ViewCustom to ImHex. This also creates a new entry in the View menu
    ContentRegistry::Views::add<ViewCustom>();
}
```

--------------------------------

### Build ImHex with CMake and Ninja

Source: https://github.com/werwolv/imhex/blob/master/dist/compiling/linux.md

Configures and compiles the project using the Ninja build system.

```bash
cd ImHex
mkdir -p build
cd build
CC=gcc-16 CXX=g++-16                          \
cmake -G "Ninja"                              \
    -DCMAKE_BUILD_TYPE=Release                \
    -DCMAKE_INSTALL_PREFIX="/usr"             \
    ..
ninja install
```

--------------------------------

### Configure ImHex Plugin Project

Source: https://github.com/werwolv/imhex/blob/master/cmake/sdk/template/CMakeLists.txt

Initializes the CMake project and validates the required IMHEX_SDK_PATH environment variable.

```cmake
cmake_minimum_required(VERSION 3.20)
project(ImHexPlugin)

# Include the ImHex SDK
# For this to work, you need to set the IMHEX_SDK_PATH environment variable to the path of the ImHex SDK
#
# On Windows, the SDK is next to the ImHex executable
# On Linux, the SDK is usually in /usr/share/imhex/sdk but this may vary depending on your distribution
# On MacOS, the SDK is located inside of the ImHex.app bundle under ImHex.app/Contents/Resources/sdk
if (NOT EXISTS $ENV{IMHEX_SDK_PATH})
    message(FATAL_ERROR "The IMHEX_SDK_PATH environment variable is not set")
endif()
add_subdirectory($ENV{IMHEX_SDK_PATH} ImHexSDK)

# Register the plugin
# This will configure everything you need to make your plugin work
# Modify the arguments to your needs. Right now it defines a plugin called `example_plugin`
# with a single source file called `example_plugin.cpp` in the `source` directory
# By default you have access to the libimhex library to interact with ImHex
# as well as libwolv, libromfs, libfmt and ImGui, but you can link against any libraries you want
add_imhex_plugin(
    NAME
        example_plugin
    SOURCES
        source/example_plugin.cpp
)
```

--------------------------------

### Set interface include directories

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imnodes/CMakeLists.txt

Configures the include directories for the imgui_all_includes interface target.

```cmake
target_include_directories(imgui_all_includes INTERFACE include)
```

--------------------------------

### Import Core Libraries

Source: https://github.com/werwolv/imhex/blob/master/cmake/sdk/CMakeLists.txt

Configures paths and properties for core ImHex libraries based on the target operating system.

```cmake
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)

set(IMHEX_PLUGIN_IMPORTED ON)

add_subdirectory(lib/libimhex)
add_subdirectory(lib/trace)
add_subdirectory(lib/fonts)
add_subdirectory(lib/ui)

set(IMHEX_PLUGIN_IMPORTED OFF)

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}/../../../lib/libimhex.so"
            INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/lib/libimhex/include")
    set_target_properties(tracing PROPERTIES
            IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libtracing.a"
            INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/lib/trace/include")
endif()
```

--------------------------------

### Build ImHex with Docker

Source: https://github.com/werwolv/imhex/blob/master/dist/compiling/docker.md

General command to build ImHex packages using a specified Dockerfile. Replace <DOCKERFILE_PATH> with the appropriate path from the provided build table.

```bash
docker buildx build . -f <DOCKERFILE_PATH> --progress plain --build-arg 'JOBS=4' --build-arg 'BUILD_TYPE=Debug' --build-context imhex=$(pwd) --output local
```

--------------------------------

### Configure pkg-config file

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/nlohmann_json/CMakeLists.txt

Generates a pkg-config file from a template to allow external tools to locate the library.

```cmake
CONFIGURE_FILE(
    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in"
    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
)
```

--------------------------------

### Define Main Executable and Sources

Source: https://github.com/werwolv/imhex/blob/master/main/gui/CMakeLists.txt

Defines the main executable target and includes all necessary source files for window management, messaging, and initialization.

```cmake
project(main)

add_executable(main ${APPLICATION_TYPE}
    source/main.cpp
    source/crash_handlers.cpp

    source/window/window.cpp
    source/window/platform/windows.cpp
    source/window/platform/macos.cpp
    source/window/platform/linux.cpp
    source/window/platform/web.cpp

    source/messaging/common.cpp
    source/messaging/linux.cpp
    source/messaging/macos.cpp
    source/messaging/windows.cpp
    source/messaging/web.cpp

    source/init/splash_window.cpp
    source/init/tasks.cpp

    source/init/run/common.cpp
    source/init/run/desktop.cpp
    source/init/run/web.cpp
    source/init/run/cli.cpp

    ${IMHEX_ICON}
)
```

--------------------------------

### Configure Tracing Library Build

Source: https://github.com/werwolv/imhex/blob/master/lib/trace/CMakeLists.txt

Defines the tracing library target and sets up source files and dependencies based on build options.

```cmake
project(tracing)

option(IMHEX_TRACE_EXCEPTIONS "Hook thrown exceptions to display a stack trace when possible" ON)

if (IMHEX_EXTERNAL_PLUGIN_BUILD)
    add_library(tracing IMPORTED SHARED GLOBAL)

    set(LIBIMHEX_LIBRARY_TYPE_PUBLIC INTERFACE)
    set(LIBIMHEX_LIBRARY_TYPE_PRIVATE INTERFACE)
else()
    if (IMHEX_STATIC_LINK_PLUGINS)
        set(TRACING_LIBRARY_TYPE OBJECT)
    else()
        set(TRACING_LIBRARY_TYPE STATIC)
    endif()

    add_library(tracing ${TRACING_LIBRARY_TYPE}
            source/stacktrace.cpp
            source/exceptions.cpp
    )
    target_link_libraries(tracing PRIVATE LLVMDemangle ${FMT_LIBRARIES})

    set(LIBIMHEX_LIBRARY_TYPE_PUBLIC PUBLIC)
    set(LIBIMHEX_LIBRARY_TYPE_PRIVATE PRIVATE)
endif()

target_include_directories(tracing ${LIBIMHEX_LIBRARY_TYPE_PUBLIC} include ${LLVM_INCLUDE_DIRS})
```

--------------------------------

### Configure .NET Scripting Support

Source: https://github.com/werwolv/imhex/blob/master/plugins/script_loader/CMakeLists.txt

Conditional block that detects CoreClrEmbed and configures the .NET runtime environment for the plugin.

```cmake
find_package(CoreClrEmbed)
add_library(dotnet INTERFACE)
if (CoreClrEmbed_FOUND)
    set(IMHEX_DOTNET_SCRIPT_SUPPORT ON)

    target_compile_definitions(dotnet INTERFACE IMHEX_DOTNET_RUNTIME_VERSION="${CoreClrEmbed_VERSION}")

    add_library(nethost SHARED IMPORTED)
    target_include_directories(nethost INTERFACE "${CoreClrEmbed_INCLUDE_DIRS}")
    get_filename_component(CoreClrEmbed_FOLDER ${CoreClrEmbed_SHARED_LIBRARIES} DIRECTORY)
    set_target_properties(nethost
            PROPERTIES
            IMPORTED_IMPLIB     ${CoreClrEmbed_SHARED_LIBRARIES}
            IMPORTED_LOCATION   ${CoreClrEmbed_LIBRARIES}
            BUILD_RPATH         ${CoreClrEmbed_FOLDER}
            INSTALL_RPATH       ${CoreClrEmbed_FOLDER})

    set(EXTRA_BUNDLE_LIBRARY_PATHS ${EXTRA_BUNDLE_LIBRARY_PATHS} "${CoreClrEmbed_FOLDER}" PARENT_SCOPE)

    if (IMHEX_BUNDLE_DOTNET)
        install(FILES ${CoreClrEmbed_SHARED_LIBRARIES} DESTINATION ${CMAKE_INSTALL_LIBDIR})
    endif()

    message(STATUS "Enabling .NET Scripting support!")

    target_link_directories(dotnet INTERFACE ${CoreClrEmbed_FOLDER})
    target_include_directories(dotnet INTERFACE ${CoreClrEmbed_INCLUDE_DIRS})
    target_compile_definitions(dotnet INTERFACE IMHEX_DOTNET_SCRIPT_SUPPORT=1)
    target_sources(dotnet INTERFACE
            source/loaders/dotnet/dotnet_loader.cpp
    )

    add_subdirectory(support/dotnet)
    add_dependencies(dotnet AssemblyLoader)
endif()
```

--------------------------------

### Configure Platform-Specific Dependencies

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/backend/CMakeLists.txt

Handles X11 library discovery and linking for non-Apple/non-Emscripten Unix systems.

```cmake
    if (UNIX AND NOT APPLE AND NOT EMSCRIPTEN)
        find_package(X11)
        target_include_directories(imgui_backend PUBLIC ${X11_INCLUDE_DIR})
        target_link_libraries(imgui_backend PUBLIC ${X11_LIBRARIES})
    endif()
```

--------------------------------

### Configure ImGui Test Engine Library

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imgui_test_engine/CMakeLists.txt

Defines the library target and its source files when the test engine is enabled.

```cmake
cmake_minimum_required(VERSION 3.16)
# https://github.com/ocornut/imgui_test_engine
project(imgui_test_engine)

set(CMAKE_CXX_STANDARD 23)

if (IMHEX_ENABLE_IMGUI_TEST_ENGINE AND NOT IMHEX_EXTERNAL_PLUGIN_BUILD)
    add_library(imgui_test_engine OBJECT
            source/imgui_capture_tool.cpp
            source/imgui_te_context.cpp
            source/imgui_te_coroutine.cpp
            source/imgui_te_engine.cpp
            source/imgui_te_exporters.cpp
            source/imgui_te_perftool.cpp
            source/imgui_te_ui.cpp
            source/imgui_te_utils.cpp
    )

    target_include_directories(imgui_test_engine PUBLIC
        include
    )
    target_link_libraries(imgui_test_engine PRIVATE imgui_includes imgui_implot)
    target_compile_definitions(imgui_test_engine PUBLIC IMGUI_TEST_ENGINE=1)
    target_compile_definitions(imgui_test_engine PRIVATE EXPORT_SYMBOLS=1)

    if (MSVC)
        target_compile_options(imgui_test_engine PUBLIC /wd4251)
    endif()
endif()
```

--------------------------------

### Add a Custom Setting

Source: https://github.com/werwolv/imhex/wiki/Plugins-Development-Guide

Expose configuration options in the Preferences interface using ContentRegistry::Settings::add, which handles JSON persistence.

```cpp
#include <plugin.hpp>

IMHEX_PLUGIN_SETUP("Custom setting", "WerWolv", "Plugin that adds a new setting") {
    ContentRegistry::Settings::add("My Category", "My Setting", "Default Value" /* or an integer */, [](auto &json) {
        // This function gets called when the settings interface is drawn. Draw your interface with ImGui here
        // When a setting is changed, write the new value to the json parameter. Or read from it to get the current value
        // If no entry in the settings json is available yet, the default value will be written to it. This may be a string or an int
        // Return true if the setting was changed, otherwise return false

        bool checkboxValue = json;
        if (ImGui::CheckBox("##checkbox", &checkboxValue)) {
           json = checkboxValue;
           return true;
        }
        
        return false;
    });
}
```

--------------------------------

### Define ImHex UI Plugin with CMake

Source: https://github.com/werwolv/imhex/blob/master/plugins/ui/CMakeLists.txt

Configures the UI plugin by specifying source files, include directories, and required libraries.

```cmake
cmake_minimum_required(VERSION 3.16)

include(ImHexPlugin)

add_imhex_plugin(
    NAME
        ui
    SOURCES
        source/library_ui.cpp

        source/ui/hex_editor.cpp
        source/ui/pattern_drawer.cpp
        source/ui/visualizer_drawer.cpp
        source/ui/menu_items.cpp
        source/ui/pattern_value_editor.cpp
        source/ui/widgets.cpp
        source/ui/markdown.cpp
        source/ui/text_editor/editor.cpp
        source/ui/text_editor/highlighter.cpp
        source/ui/text_editor/navigate.cpp
        source/ui/text_editor/render.cpp
        source/ui/text_editor/support.cpp
        source/ui/text_editor/utf8.cpp
        source/ui/text_editor/code_folder.cpp
    INCLUDES
        include
    LIBRARIES
        fonts
        md4c::md4c
    LIBRARY_PLUGIN
)
```

--------------------------------

### Construct Str with format strings

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imgui_test_engine/include/thirdparty/Str/README.md

Using the 'f' suffix helper types for formatted string construction.

```cpp
Str256f filename("%s/%s.tmp", folder, filename);             // construct (w/format)
fopen(Str256f("%s/%s.tmp, folder, filename).c_str(), "rb");  // construct (w/format), use as function param, destruct
```

--------------------------------

### Miniaudio CMake Build Configuration

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/miniaudio/CMakeLists.txt

Defines the miniaudio static library, includes necessary directories, and applies platform-specific compiler flags.

```cmake
cmake_minimum_required(VERSION 3.16)
project(miniaudio)

add_library(miniaudio STATIC
        source/miniaudio.c
)

target_include_directories(miniaudio PUBLIC include)
if (APPLE)
    set_source_files_properties(source/miniaudio.c PROPERTIES LANGUAGE OBJC)
elseif (NOT MSVC)
    target_compile_options(miniaudio PRIVATE -Wno-unused-result)
endif ()
```

--------------------------------

### Create Str references

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imgui_test_engine/include/thirdparty/Str/README.md

Using StrRef to point to literals or existing strings without allocation or copying.

```cpp
StrRef ref("literal");                   // copy pointer, no allocation, no string copy
StrRef ref2(GetDebugName());             // copy pointer. no tracking of anything whatsoever, know what you are doing!
```

--------------------------------

### Target Properties and Definitions

Source: https://github.com/werwolv/imhex/blob/master/main/gui/CMakeLists.txt

Sets output names and compile definitions for the main target.

```cmake
set_target_properties(main PROPERTIES
    OUTPUT_NAME "${IMHEX_APPLICATION_NAME}"
    RUNTIME_OUTPUT_DIRECTORY "${IMHEX_MAIN_OUTPUT_DIRECTORY}"
)

target_compile_definitions(main PRIVATE IMHEX_PROJECT_NAME="${PROJECT_NAME}")
```

--------------------------------

### Handle Link Creation

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imnodes/README.md

Check for new links created by the user after the editor has finished rendering.

```cpp
int start_attr, end_attr;
if (ImNodes::IsLinkCreated(&start_attr, &end_attr))
{
  links.push_back(std::make_pair(start_attr, end_attr));
}
```

--------------------------------

### ImGui CMake Configuration

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/CMakeLists.txt

Defines the project requirements, subdirectories, and library exports for the ImGui build system.

```cmake
cmake_minimum_required(VERSION 3.16)
project(imgui)

set(CMAKE_CXX_STANDARD 23)

add_library(imgui_all_includes INTERFACE)

add_subdirectory(imgui)
add_subdirectory(cimgui)
add_subdirectory(implot)
add_subdirectory(implot3d)
add_subdirectory(imnodes)
add_subdirectory(backend)
add_subdirectory(imgui_test_engine)

set(IMGUI_LIBRARIES imgui_imgui imgui_cimgui imgui_implot imgui_implot3d imgui_imnodes imgui_backend)
set(IMGUI_LIBRARIES ${IMGUI_LIBRARIES} PARENT_SCOPE)

if (NOT IMHEX_EXTERNAL_PLUGIN_BUILD)
    foreach (LIBRARY IN LISTS IMGUI_LIBRARIES)
        target_compile_definitions(${LIBRARY} PRIVATE EXPORT_SYMBOLS=1)
    endforeach ()
endif()
```

--------------------------------

### Read a tar archive in C

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/microtar/README.md

Demonstrates opening an archive, iterating through headers, and reading specific file contents.

```c
mtar_t tar;
mtar_header_t h;
char *p;

/* Open archive for reading */
mtar_open(&tar, "test.tar", "r");

/* Print all file names and sizes */
while ( (mtar_read_header(&tar, &h)) != MTAR_ENULLRECORD ) {
  printf("%s (%d bytes)\n", h.name, h.size);
  mtar_next(&tar);
}

/* Load and print contents of file "test.txt" */
mtar_find(&tar, "test.txt", &h);
p = calloc(1, h.size + 1);
mtar_read_data(&tar, p, h.size);
printf("%s", p);
free(p);

/* Close archive */
mtar_close(&tar);
```

--------------------------------

### Configure CMake package files

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/nlohmann_json/CMakeLists.txt

Configures version and project config files using templates for find_package support.

```cmake
include(CMakePackageConfigHelpers)
# use a custom package version config file instead of
# write_basic_package_version_file to ensure that it's architecture-independent
# https://github.com/nlohmann/json/issues/1697
configure_file(
    "cmake/nlohmann_jsonConfigVersion.cmake.in"
    ${NLOHMANN_JSON_CMAKE_VERSION_CONFIG_FILE}
    @ONLY
)
configure_file(
    ${NLOHMANN_JSON_CMAKE_CONFIG_TEMPLATE}
    ${NLOHMANN_JSON_CMAKE_PROJECT_CONFIG_FILE}
    @ONLY
)
```

--------------------------------

### Register and Define a Test Case

Source: https://github.com/werwolv/imhex/blob/master/lib/third_party/imgui/imgui_test_engine/README.md

Registers a new test using IM_REGISTER_TEST and defines its behavior using an ImGuiTestContext to interact with UI elements.

```cpp
ImGuiTest* test = IM_REGISTER_TEST(e, "demo_test", "test1");
test->TestFunc = [](ImGuiTestContext* ctx)
{
    ctx->SetRef("My Window");           // Set a base path so we don't have to specify full path afterwards
    ctx->ItemClick("My Button");        // Click "My Button" inside "My Window"
    ctx->ItemCheck("Node/Checkbox");    // Open "Node", find "Checkbox", ensure it is checked if not checked already.
    ctx->ItemInputValue("Slider", 123); // Find "Slider" and set the value to 123
    IM_CHECK_EQ(app->SliderValue, 123); // Check value on app side
    
    ctx->MenuCheck("//Dear ImGui Demo/Tools/About Dear ImGui"); // Show Dear ImGui About Window (assume Demo window is open)
};
```

--------------------------------

### Add a Tool Entry

Source: https://github.com/werwolv/imhex/wiki/Plugins-Development-Guide

Register small utility features in the tools window using ContentRegistry::Tools::add.

```cpp
#include <plugin.hpp>

IMHEX_PLUGIN_SETUP("Custom tool", "WerWolv", "Plugin that adds a new tool") {
    ContentRegistry::Tools::add("My Fancy Tool", [] {
        // Call into ImHex here to create your new tools interface
    });
}
```
Tokens:
Raw