webview

https://github.com/webview/webview
Admin
webview is a tiny cross-platform webview library for C/C++ to build modern cross-platform GUIs.
Tokens:6,562
Snippets:64
Trust Score:7.5
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Cross-compile for Windows x64

Source: https://github.com/webview/webview/blob/master/README.md

Example command to target Windows x64 on Linux using a specific toolchain file.

```sh
cmake -G "Ninja Multi-Config" -B build -S . -D CMAKE_TOOLCHAIN_FILE=cmake/toolchains/x86_64-w64-mingw32.cmake -D WEBVIEW_TOOLCHAIN_EXECUTABLE_SUFFIX=-posix
cmake --build build --config CONFIG
```

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

### Define Webview Executable Targets

Source: https://github.com/webview/webview/blob/master/examples/CMakeLists.txt

Defines build targets for basic and binding-enabled C and C++ examples, linking against static or dynamic webview cores.

```cmake
add_executable(webview_example_basic_c MACOSX_BUNDLE WIN32)
target_sources(webview_example_basic_c PRIVATE basic.c ${SHARED_SOURCES})
target_link_libraries(webview_example_basic_c PRIVATE webview::core_static)

add_executable(webview_example_basic_cc MACOSX_BUNDLE WIN32)
target_sources(webview_example_basic_cc PRIVATE basic.cc ${SHARED_SOURCES})
target_link_libraries(webview_example_basic_cc PRIVATE webview::core)

add_executable(webview_example_bind_c MACOSX_BUNDLE WIN32)
target_sources(webview_example_bind_c PRIVATE bind.c ${SHARED_SOURCES})
target_link_libraries(webview_example_bind_c PRIVATE webview::core_static Threads::Threads)

if(MSVC)
    # Disable some warnings when using MSVC
    target_compile_definitions(webview_example_bind_c PRIVATE _CRT_SECURE_NO_WARNINGS)
endif()

add_executable(webview_example_bind_cc MACOSX_BUNDLE WIN32)
target_sources(webview_example_bind_cc PRIVATE bind.cc ${SHARED_SOURCES})
target_link_libraries(webview_example_bind_cc PRIVATE webview::core Threads::Threads)
```

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

### Conditional build configuration

Source: https://github.com/webview/webview/blob/master/CMakeLists.txt

Includes optional subdirectories for tests, examples, documentation, and packaging based on defined CMake variables.

```cmake
if(WEBVIEW_BUILD)
    add_subdirectory(compatibility)

    if(WEBVIEW_BUILD_TESTS)
        include(CTest)
        add_subdirectory(test_driver)
    endif()

    add_subdirectory(core)

    if(WEBVIEW_BUILD_EXAMPLES)
        add_subdirectory(examples)
    endif()

    if(WEBVIEW_BUILD_DOCS)
        add_subdirectory(docs)
    endif()

    if(WEBVIEW_INSTALL_TARGETS)
        webview_install_targets()
    endif()

    if(WEBVIEW_ENABLE_PACKAGING)
        add_subdirectory(packaging)
    endif()
endif()
```

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

### Configure Webview Build Environment

Source: https://github.com/webview/webview/blob/master/examples/CMakeLists.txt

Initializes required dependencies and platform-specific resource files for the project.

```cmake
find_package(Threads REQUIRED)

set(COPYRIGHT "Copyright [year], Your Name")
set(VENDOR "Your Name")
set(DESCRIPTION "Example app made with webview")
set(SHARED_SOURCES)

if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    include(resources/macos/resources.cmake)
elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    include(resources/windows/resources.cmake)
endif()
```

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

### Initialize webview project with CMake

Source: https://github.com/webview/webview/blob/master/CMakeLists.txt

Sets the minimum CMake version, extracts the version number, and defines the project metadata.

```cmake
cmake_minimum_required(VERSION 3.16)

include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/internal.cmake")
webview_extract_version()

project(
    webview
    VERSION "${WEBVIEW_VERSION_NUMBER}"
    DESCRIPTION "A tiny cross-platform webview library for C/C++ to build modern cross-platform GUIs."
    HOMEPAGE_URL https://github.com/webview/webview)

webview_init()
```

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

### C++ Application Entry Point

Source: https://github.com/webview/webview/blob/master/README.md

Basic C++ implementation using the webview class.

```cpp
#include "webview/webview.h"

#include <iostream>

#ifdef _WIN32
int WINAPI WinMain(HINSTANCE /*hInst*/, HINSTANCE /*hPrevInst*/,
                   LPSTR /*lpCmdLine*/, int /*nCmdShow*/) {
#else
int main() {
#endif
  try {
    webview::webview w(false, nullptr);
    w.set_title("Basic Example");
    w.set_size(480, 320, WEBVIEW_HINT_NONE);
    w.set_html("Thanks for using webview!");
    w.run();
  } catch (const webview::exception &e) {
    std::cerr << e.what() << '\n';
    return 1;
  }

  return 0;
}
```

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

### C Application Entry Point

Source: https://github.com/webview/webview/blob/master/README.md

Basic C implementation using the webview C API.

```c
#include "webview/webview.h"
#include <stddef.h>

#ifdef _WIN32
#include <windows.h>
#endif

#ifdef _WIN32
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine,
                   int nCmdShow) {
  (void)hInst;
  (void)hPrevInst;
  (void)lpCmdLine;
  (void)nCmdShow;
#else
int main(void) {
#endif
  webview_t w = webview_create(0, NULL);
  webview_set_title(w, "Basic Example");
  webview_set_size(w, 480, 320, WEBVIEW_HINT_NONE);
  webview_set_html(w, "Thanks for using webview!");
  webview_run(w);
  webview_destroy(w);
  return 0;
}
```

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

### Package the project

Source: https://github.com/webview/webview/blob/master/README.md

Create a package after building both Debug and Release configurations.

```sh
cd build
cpack -G External -C "Debug;Release" --config CPackConfig.cmake
```

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

### Define Webview Core Interface Library

Source: https://github.com/webview/webview/blob/master/core/CMakeLists.txt

Sets up the interface library for core headers, including include directories and dependency linking.

```cmake
add_library(webview_core_headers INTERFACE)
add_library(webview::core ALIAS webview_core_headers)
target_include_directories(
    webview_core_headers
    INTERFACE
        "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
target_link_libraries(webview_core_headers INTERFACE ${WEBVIEW_DEPENDENCIES})
# Note that we also use CMAKE_CXX_STANDARD which can override this
target_compile_features(webview_core_headers INTERFACE cxx_std_11)
set_target_properties(webview_core_headers PROPERTIES
    EXPORT_NAME core)

if(CMAKE_SYSTEM_NAME STREQUAL "Windows" AND WEBVIEW_USE_COMPAT_MINGW)
    target_link_libraries(webview_core_headers INTERFACE webview::compat_mingw)
endif()
```

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

### C Project Configuration

Source: https://github.com/webview/webview/blob/master/README.md

CMake configuration for a C webview project using static linking.

```cmake
cmake_minimum_required(VERSION 3.16)
project(example LANGUAGES C CXX)

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")

include(FetchContent)

FetchContent_Declare(
    webview
    GIT_REPOSITORY https://github.com/webview/webview
    GIT_TAG 0.12.0)
FetchContent_MakeAvailable(webview)

add_executable(example WIN32)
target_sources(example PRIVATE main.c)
target_link_libraries(example PRIVATE webview::core_static)
```

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

### Build the project with CMake

Source: https://github.com/webview/webview/blob/master/README.md

Configure and build the project using the Ninja generator. Replace CONFIG with Debug, Release, or Profile.

```sh
cmake -G "Ninja Multi-Config" -B build -S .
cmake --build build --config CONFIG
```

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

### Define Webview Test Driver Library

Source: https://github.com/webview/webview/blob/master/test_driver/CMakeLists.txt

Configures the webview_test_driver as a static library, specifies its source files, and sets the public include directory.

```cmake
add_library(webview_test_driver STATIC)
target_sources(webview_test_driver PRIVATE src/test_driver.cc)
target_include_directories(webview_test_driver PUBLIC include)
```

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

### Generate SWIG Bindings

Source: https://github.com/webview/webview/blob/master/README.md

Use these commands to generate language-specific bindings from the webview.i interface file. Ensure the build directory structure is created before running the SWIG commands.

```sh
mkdir -p build/bindings/{python,csharp,java,ruby}
swig -c++ -python -outdir build/bindings/python -o build/bindings/python/python_wrap.cpp webview.i
swig -c++ -csharp -outdir build/bindings/csharp -o build/bindings/csharp/csharp_wrap.cpp webview.i
swig -c++ -java -outdir build/bindings/java -o build/bindings/java/java_wrap.cpp webview.i
swig -c++ -ruby -outdir build/bindings/ruby -o build/bindings/ruby/ruby_wrap.cpp webview.i
```

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

### C++ Project Configuration

Source: https://github.com/webview/webview/blob/master/README.md

CMake configuration for a C++ webview project using FetchContent.

```cmake
cmake_minimum_required(VERSION 3.16)
project(example LANGUAGES CXX)

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")

include(FetchContent)

FetchContent_Declare(
    webview
    GIT_REPOSITORY https://github.com/webview/webview
    GIT_TAG 0.12.0)
FetchContent_MakeAvailable(webview)

add_executable(example WIN32)
target_sources(example PRIVATE main.cc)
target_link_libraries(example PRIVATE webview::core)
```

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

### Run tests

Source: https://github.com/webview/webview/blob/master/README.md

Execute the test suite using ctest.

```sh
ctest --test-dir build --build-config CONFIG
```

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

### CMake Configuration for Webview

Source: https://github.com/webview/webview/blob/master/packaging/test/CMakeLists.txt

Configures the project, handles Windows-specific compatibility for EventToken.h, and links the webview core library.

```cmake
cmake_minimum_required(VERSION 3.16)
project(example LANGUAGES C CXX)

# Workaround for missing "EventToken.h" (used by MS WebView2) when targetting Windows
if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    include(CheckCXXSourceCompiles)
    check_cxx_source_compiles("#include <eventtoken.h>" HAVE_EVENTTOKEN_H)
    if(NOT HAVE_EVENTTOKEN_H)
        include_directories(../../compatibility/mingw/include)
    endif()
endif()

find_package(webview REQUIRED CONFIG)

add_executable(example WIN32 ../../examples/cc/basic/src/main.cc)
target_link_libraries(example PRIVATE webview::core)
```

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

### Configure External Packaging Script

Source: https://github.com/webview/webview/blob/master/packaging/CMakeLists.txt

Sets up the custom packaging script and enables staging for the External CPack generator.

```cmake
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/external_package.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/external_package.cmake" @ONLY)
set(CPACK_EXTERNAL_PACKAGE_SCRIPT "${CMAKE_CURRENT_BINARY_DIR}/external_package.cmake")
set(CPACK_EXTERNAL_ENABLE_STAGING TRUE)

include(CPack)
```

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

### Configure Doxygen and Custom Build Target

Source: https://github.com/webview/webview/blob/master/docs/api/CMakeLists.txt

Initializes Doxygen, sets configuration variables, and defines a custom command to generate documentation during the build process.

```cmake
webview_find_doxygen(${WEBVIEW_IS_CI})

if(NOT Doxygen_FOUND)
    message(WARNING "Skipping docs as Doxygen was not found")
    return()
endif()

# We can set this to "-$<CONFIG>" if we need per-config documentation
set(CONFIG_SUFFIX "")
set(DOXYFILE_HAVE_DOT YES)
set(DOXYFILE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/output${CONFIG_SUFFIX}")
set(DOXYFILE_CLANG_DATABASE_PATH "${PROJECT_BINARY_DIR}")
set(DOXYFILE_USE_MDFILE_AS_MAINPAGE "${PROJECT_SOURCE_DIR}/README.md")

get_target_property(CORE_SOURCE_DIR webview::core SOURCE_DIR)
set(DOXYFILE_INPUT "${CORE_SOURCE_DIR}/include")

set(RUN_DOXYGEN_FILE "${CMAKE_CURRENT_BINARY_DIR}/run_doxygen${CONFIG_SUFFIX}.cmake")

file(GLOB_RECURSE DOCS_INPUT_FILES CONFIGURE_DEPENDS "${DOXYFILE_INPUT}/**")

file(GENERATE
    OUTPUT "${RUN_DOXYGEN_FILE}"
    CONTENT "set(DOXYGEN_EXECUTABLE \"${DOXYGEN_EXECUTABLE}\")\n\
set(PROJECT_NAME \"${PROJECT_NAME}\")\n\
set(PROJECT_VERSION \"${PROJECT_VERSION}\")\n\
set(PROJECT_DESCRIPTION \"${PROJECT_DESCRIPTION}\")\n\
set(DOXYFILE_HAVE_DOT \"${DOXYFILE_HAVE_DOT}\")\n\
set(DOXYFILE_OUTPUT_DIRECTORY \"${DOXYFILE_OUTPUT_DIRECTORY}\")\n\
set(DOXYFILE_INPUT \"${DOXYFILE_INPUT}\")\n\
set(DOXYFILE_USE_MDFILE_AS_MAINPAGE \"${DOXYFILE_USE_MDFILE_AS_MAINPAGE}\")\n\
set(DOXYFILE_CLANG_DATABASE_PATH \"${DOXYFILE_CLANG_DATABASE_PATH}\")\n\
configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in\" \"${CMAKE_CURRENT_BINARY_DIR}/Doxyfile${CONFIG_SUFFIX}\" @ONLY)\n\
execute_process(COMMAND \"${DOXYGEN_EXECUTABLE}\" \"${CMAKE_CURRENT_BINARY_DIR}/Doxyfile${CONFIG_SUFFIX}\")"
)

set(API_DOCS_STAMP_FILE "${CMAKE_CURRENT_BINARY_DIR}/webview_api_docs${CONFIG_SUFFIX}.stamp")
add_custom_command(
    OUTPUT "${API_DOCS_STAMP_FILE}"
    COMMAND "${CMAKE_COMMAND}" -E touch "${API_DOCS_STAMP_FILE}"
    COMMAND "${CMAKE_COMMAND}" -E rm -rf "${DOXYFILE_OUTPUT_DIRECTORY}"
    COMMAND "${CMAKE_COMMAND}" -P "${RUN_DOXYGEN_FILE}"
    DEPENDS ${DOCS_INPUT_FILES} "${RUN_DOXYGEN_FILE}"
    VERBATIM)

add_custom_target(webview_api_docs ALL DEPENDS "${API_DOCS_STAMP_FILE}")

if(WEBVIEW_INSTALL_DOCS)
    install(DIRECTORY "${DOXYFILE_OUTPUT_DIRECTORY}/html"
        DESTINATION "${CMAKE_INSTALL_DOCDIR}"
        COMPONENT webview_api_docs)
endif()
```

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

### Build Commands

Source: https://github.com/webview/webview/blob/master/README.md

Commands to build the project using CMake and generate the amalgamated library.

```sh
cmake -G Ninja -B build -S . -D CMAKE_BUILD_TYPE=Release
cmake --build build
```

```sh
python3 scripts/amalgamate/amalgamate.py --base core --search include --output webview_amalgamation.h src
```

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

### Configure CPack Package Metadata

Source: https://github.com/webview/webview/blob/master/packaging/CMakeLists.txt

Sets basic package information including name, version, and license file.

```cmake
set(CPACK_PACKAGE_NAME webview)
set(CPACK_PACKAGE_VENDOR webview organization)
set(CPACK_PACKAGE_VERSION ${WEBVIEW_VERSION})
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "A tiny cross-platform webview library for C/C++ to build modern cross-platform GUIs")
set(CPACK_PACKAGE_INSTALL_DIRECTORY "${CPACK_PACKAGE_NAME}")
set(CPACK_RESOURCE_FILE_LICENSE ${PROJECT_SOURCE_DIR}/LICENSE)
set(CPACK_VERBATIM_VARIABLES TRUE)
```

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

### Configure Static Library Build

Source: https://github.com/webview/webview/blob/master/core/CMakeLists.txt

Conditionally builds the static library version of the webview core, handling MSVC naming requirements.

```cmake
if(WEBVIEW_BUILD_STATIC_LIBRARY)
    # Change .lib file name for MSVC because otherwise it would be the same for shared and static
    if(MSVC)
        set(STATIC_LIBRARY_OUTPUT_NAME webview_static)
    else()
        set(STATIC_LIBRARY_OUTPUT_NAME webview)
    endif()

    add_library(webview_core_static STATIC)
    add_library(webview::core_static ALIAS webview_core_static)
    target_sources(webview_core_static PRIVATE src/webview.cc)
    target_link_libraries(webview_core_static PUBLIC webview_core_headers)
    set_target_properties(webview_core_static PROPERTIES
        OUTPUT_NAME "${STATIC_LIBRARY_OUTPUT_NAME}"
        POSITION_INDEPENDENT_CODE ON
        EXPORT_NAME core_static)
    target_compile_definitions(webview_core_static PUBLIC WEBVIEW_STATIC)
endif()
```

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

### Configure Packaging Environment Variables

Source: https://github.com/webview/webview/blob/master/packaging/CMakeLists.txt

Sets conditional suffixes for runtime, architecture, and MSYS/MINGW environments.

```cmake
if(WEBVIEW_USE_STATIC_MSVC_RUNTIME)
    set(RUNTIME_SUFFIX "-static_rt")
endif()

if(APPLE AND CMAKE_OSX_ARCHITECTURES MATCHES ";")
    set(PACKAGE_NAME_ARCH universal)
else()
    set(PACKAGE_NAME_ARCH ${CMAKE_SYSTEM_PROCESSOR_LC})
endif()

if((MSYS OR MINGW) AND DEFINED ENV{MSYSTEM})
    string(TOLOWER "$ENV{MSYSTEM}" MSYSTEM)
    set(MSYSTEM_SUFFIX "-${MSYSTEM}")
endif()
```

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

### Git Ignore Configuration

Source: https://github.com/webview/webview/blob/master/README.md

Standard ignore file for build artifacts.

```text
# Build artifacts
/build
```

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

### Define MinGW Compatibility Library

Source: https://github.com/webview/webview/blob/master/compatibility/mingw/CMakeLists.txt

Creates an interface library and sets include directories for MinGW compatibility when the system name is Windows.

```cmake
if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    add_library(webview_compat_mingw INTERFACE)
    add_library(webview::compat_mingw ALIAS webview_compat_mingw)
    set_target_properties(webview_compat_mingw PROPERTIES
        EXPORT_NAME compat_mingw)
    target_include_directories(
        webview_compat_mingw
        INTERFACE
            "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
            "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
endif()
```

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

### Amalgamation Build Process

Source: https://github.com/webview/webview/blob/master/core/CMakeLists.txt

Generates a single-header amalgamation of the library using a Python script if enabled.

```cmake
if(WEBVIEW_BUILD_AMALGAMATION)
    webview_find_python3(${WEBVIEW_IS_CI})
    if(Python3_FOUND)
        webview_find_clang_format(${WEBVIEW_IS_CI})
        if(WEBVIEW_CLANG_FORMAT_EXE)
            file(GLOB_RECURSE HEADER_FILES CONFIGURE_DEPENDS include/**)
            file(GLOB_RECURSE SOURCE_FILES CONFIGURE_DEPENDS src/**)
            set(AMALGAMATION_STAMP_FILE "${CMAKE_CURRENT_BINARY_DIR}/amalgamation/webview.h.stamp")

            add_custom_command(
                OUTPUT "${AMALGAMATION_STAMP_FILE}"
                COMMAND "${CMAKE_COMMAND}" -E touch "${AMALGAMATION_STAMP_FILE}"
                COMMAND ${Python3_EXECUTABLE}
                    "${PROJECT_SOURCE_DIR}/scripts/amalgamate/amalgamate.py"
                    --clang-format-exe "${WEBVIEW_CLANG_FORMAT_EXE}"
                    --base "${CMAKE_CURRENT_SOURCE_DIR}"
                    --search include
                    --output "${CMAKE_CURRENT_BINARY_DIR}/amalgamation/webview.h"
                    ${SOURCE_FILES}
                DEPENDS ${HEADER_FILES} ${SOURCE_FILES}
                COMMENT "Building amalgamation..."
                VERBATIM)

            add_custom_target(webview_amalgamate ALL
                DEPENDS "${AMALGAMATION_STAMP_FILE}")

            install(FILES "${CMAKE_CURRENT_BINARY_DIR}/amalgamation/webview.h"
                DESTINATION .
                COMPONENT webview_amalgamation)
        else()
            message(WARNING "Skipping amalgamation as clang-format was not found")
        endif()
    else()
        message(WARNING "Skipping amalgamation as Python 3 was not found")
    endif()
endif()
```

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

### Configure Shared Library Build

Source: https://github.com/webview/webview/blob/master/core/CMakeLists.txt

Conditionally builds the shared library version of the webview core if enabled.

```cmake
if(WEBVIEW_BUILD_SHARED_LIBRARY)
    add_library(webview_core_shared SHARED)
    add_library(webview::core_shared ALIAS webview_core_shared)
    target_sources(webview_core_shared PRIVATE src/webview.cc)
    target_link_libraries(webview_core_shared PUBLIC webview_core_headers)
    set_target_properties(webview_core_shared PROPERTIES
        OUTPUT_NAME webview
        VERSION "${WEBVIEW_VERSION_NUMBER}"
        SOVERSION "${WEBVIEW_VERSION_COMPATIBILITY}"
        EXPORT_NAME core_shared)
    target_compile_definitions(webview_core_shared
        INTERFACE WEBVIEW_SHARED
        PRIVATE WEBVIEW_BUILD_SHARED)
endif()
```

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

### Manual Compiler Invocation

Source: https://github.com/webview/webview/blob/master/README.md

Platform-specific commands to compile the application using GCC/Clang-like compilers.

```sh
c++ main.cc -O2 --std=c++11 -Ilibs -framework WebKit -ldl -o example
```

```sh
c++ main.cc -O2 --std=c++11 -Ilibs $(pkg-config --cflags --libs gtk+-3.0 webkit2gtk-4.1) -ldl -o example
```

```sh
c++ main.cc -O2 --std=c++14 -static -mwindows -Ilibs -ladvapi32 -lole32 -lshell32 -lshlwapi -luser32 -lversion -o example
```

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

### Configure Core Test Executables

Source: https://github.com/webview/webview/blob/master/core/tests/CMakeLists.txt

Defines the build targets for functional and unit tests, links them against the core library and test driver, and registers them for discovery.

```cmake
include(${PROJECT_SOURCE_DIR}/test_driver/cmake/discovery.cmake)

if(MSVC)
    add_compile_options(/utf-8)
endif()

add_executable(webview_core_functional_tests)
target_sources(webview_core_functional_tests PRIVATE src/functional_tests.cc)
target_link_libraries(webview_core_functional_tests PRIVATE webview::core webview_test_driver)
webview_discover_tests(webview_core_functional_tests
    TIMEOUT 60
    TIMEOUT_AFTER_MATCH 300 "[[slow]]")

add_executable(webview_core_unit_tests)
target_sources(webview_core_unit_tests PRIVATE src/unit_tests.cc)
target_link_libraries(webview_core_unit_tests PRIVATE webview::core webview_test_driver)
webview_discover_tests(webview_core_unit_tests
    TIMEOUT 10)
```

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

### Define Archive File Names

Source: https://github.com/webview/webview/blob/master/packaging/CMakeLists.txt

Constructs the naming scheme for generated package archives.

```cmake
set(WEBVIEW_ARCHIVE_SYSTEM_ARCH_FILE_NAME "${CPACK_PACKAGE_NAME}_v${CPACK_PACKAGE_VERSION}-${COMPILER}${MSYSTEM_SUFFIX}${RUNTIME_SUFFIX}-${CMAKE_SYSTEM_NAME_LC}-${PACKAGE_NAME_ARCH}")
set(WEBVIEW_ARCHIVE_UNIVERSAL_FILE_NAME "${CPACK_PACKAGE_NAME}_v${CPACK_PACKAGE_VERSION}")
set(CPACK_SOURCE_PACKAGE_FILE_NAME "${WEBVIEW_ARCHIVE_UNIVERSAL_FILE_NAME}-source")
```

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

### Generate coverage report

Source: https://github.com/webview/webview/blob/master/README.md

Generate a test coverage report using gcovr.

```sh
gcovr
```

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

### Detect System Processor for MSVC

Source: https://github.com/webview/webview/blob/master/packaging/CMakeLists.txt

Maps MSVC generator platforms to standard system processor identifiers.

```cmake
string(TOLOWER "${CMAKE_GENERATOR_PLATFORM}" CMAKE_GENERATOR_PLATFORM_LC)
if(MSVC)
    if(CMAKE_GENERATOR_PLATFORM_LC STREQUAL "arm64")
        set(CMAKE_SYSTEM_PROCESSOR arm64)
    elseif(CMAKE_GENERATOR_PLATFORM_LC STREQUAL "amd64" OR CMAKE_GENERATOR_PLATFORM_LC STREQUAL "x64")
        set(CMAKE_SYSTEM_PROCESSOR x86_64)
    elseif(CMAKE_GENERATOR_PLATFORM_LC STREQUAL "win32" OR CMAKE_GENERATOR_PLATFORM_LC STREQUAL "x86")
        set(CMAKE_SYSTEM_PROCESSOR x86)
    endif()
endif()
```

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

### Determine Compiler Version

Source: https://github.com/webview/webview/blob/master/packaging/CMakeLists.txt

Extracts the compiler ID and version string for naming conventions.

```cmake
string(TOLOWER "${CMAKE_SYSTEM_NAME}" CMAKE_SYSTEM_NAME_LC)
string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" CMAKE_SYSTEM_PROCESSOR_LC)
string(TOLOWER "${CMAKE_CXX_COMPILER_ID}" CMAKE_CXX_COMPILER_ID_LC)

if(MSVC AND MSVC_TOOLSET_VERSION)
    set(COMPILER_VERSION "${MSVC_TOOLSET_VERSION}")
else()
    string(REPLACE "." ";" COMPILER_VERSION_LIST "${CMAKE_CXX_COMPILER_VERSION}")
    list(GET COMPILER_VERSION_LIST 0 COMPILER_VERSION_MAJOR)
    list(GET COMPILER_VERSION_LIST 1 COMPILER_VERSION_MINOR)
    set(COMPILER_VERSION "${COMPILER_VERSION_MAJOR}.${COMPILER_VERSION_MINOR}")
endif()
set(COMPILER "${CMAKE_CXX_COMPILER_ID_LC}_${COMPILER_VERSION}")
```

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

### Define Source Ignore Files and Generators

Source: https://github.com/webview/webview/blob/master/packaging/CMakeLists.txt

Configures files to ignore during source packaging and sets the generator type.

```cmake
file(TO_CMAKE_PATH "${PROJECT_BINARY_DIR}" IGNORED_BUILD_DIR)
string(REPLACE "\\" "\\\\" IGNORED_BUILD_DIR "${IGNORED_BUILD_DIR}")
set(CPACK_SOURCE_IGNORE_FILES
    \\.git/
    "^${IGNORED_BUILD_DIR}"
)
set(CPACK_SOURCE_GENERATOR TGZ)
```
Tokens:
Raw