mirror of
https://github.com/slint-ui/slint.git
synced 2025-12-23 09:19:32 +00:00
3d859a4413
Since commit 7947f233f1a744f5ce9dfdf44372727d4fefb50b in Corrosion,
cmake will default to ${CMAKE_C_COMPILER} for linking a cdylib,
which means that C must be enabled as a language in the project.
Previously, it tried C, CXX, and Fortran and picked the first one.
(cherry picked from commit 87a548a972)
425 lines
17 KiB
CMake
425 lines
17 KiB
CMake
# Copyright © SixtyFPS GmbH <info@slint.dev>
|
|
# SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-1.1 OR LicenseRef-Slint-commercial
|
|
|
|
cmake_minimum_required(VERSION 3.21)
|
|
# Select C++ and C as languages, as Corrosion needs ${CMAKE_C_COMPILER}
|
|
# for linking
|
|
project(Slint HOMEPAGE_URL "https://slint.dev/" LANGUAGES C CXX VERSION 1.0.0)
|
|
|
|
include(FeatureSummary)
|
|
include(CMakeDependentOption)
|
|
|
|
include(FetchContent)
|
|
FetchContent_Declare(
|
|
Corrosion
|
|
GIT_REPOSITORY https://github.com/corrosion-rs/corrosion.git
|
|
GIT_TAG v0.4.3
|
|
)
|
|
FetchContent_MakeAvailable(Corrosion)
|
|
|
|
list(PREPEND CMAKE_MODULE_PATH ${Corrosion_SOURCE_DIR}/cmake)
|
|
find_package(Rust 1.66 REQUIRED MODULE)
|
|
|
|
option(BUILD_SHARED_LIBS "Build Slint as shared library" ON)
|
|
option(SLINT_FEATURE_COMPILER "Enable support for compiling .slint files to C++ ahead of time" ON)
|
|
|
|
if(SLINT_FEATURE_COMPILER)
|
|
set(slint_compiler_crate "slint-compiler")
|
|
endif()
|
|
|
|
if(BUILD_SHARED_LIBS)
|
|
set(rustc_lib_type "cdylib")
|
|
set(slint_cpp_impl "slint-cpp-shared")
|
|
set(cmake_lib_type "SHARED")
|
|
else()
|
|
set(rustc_lib_type "staticlib")
|
|
set(slint_cpp_impl "slint-cpp-static")
|
|
set(cmake_lib_type "STATIC")
|
|
endif()
|
|
|
|
corrosion_import_crate(MANIFEST_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../Cargo.toml"
|
|
CRATES slint-cpp ${slint_compiler_crate} CRATE_TYPES bin ${rustc_lib_type})
|
|
|
|
set(SLINT_LIBRARY_CARGO_FLAGS "" CACHE STRING
|
|
"Flags to pass to cargo when building the Slint runtime library")
|
|
if(SLINT_LIBRARY_CARGO_FLAGS)
|
|
corrosion_set_cargo_flags(slint-cpp ${SLINT_LIBRARY_CARGO_FLAGS})
|
|
endif()
|
|
|
|
|
|
# When doing "make install" package builds, set install_name to rpath, so that the installed
|
|
# binaries don't have a load-command pointing back to their build directory.
|
|
# Don't do this when Slint is used via FetchContent. While we could set CMAKE_BUILD_RPATH to
|
|
# include the binary dir and thus our examples would have the correct rpath set, binaries
|
|
# outside (i.e. applications using Slint via FetchContent) would not and the BUILD_RPATH
|
|
# target property doesn't propagate :(
|
|
if (APPLE AND SLINT_IS_TOPLEVEL_BUILD AND BUILD_SHARED_LIBS)
|
|
# corrosion could provide the Cargo.toml package version as a CMake target property.
|
|
corrosion_add_target_local_rustflags(slint-cpp -Clink-arg=-Wl,-install_name,@rpath/libslint_cpp.dylib,-current_version,${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR},-compatibility_version,${PROJECT_VERSION_MAJOR}.0)
|
|
# Set this one to false again explicitely because Corrosion will starting setting this property to true by default.
|
|
set_target_properties(slint-cpp-shared PROPERTIES IMPORTED_NO_SONAME 0)
|
|
set_target_properties(slint-cpp-shared PROPERTIES IMPORTED_SONAME libslint_cpp.dylib)
|
|
endif()
|
|
|
|
set_property(
|
|
TARGET slint-cpp
|
|
APPEND
|
|
PROPERTY CORROSION_ENVIRONMENT_VARIABLES
|
|
"SLINT_GENERATED_INCLUDE_DIR=${CMAKE_CURRENT_BINARY_DIR}/generated_include/"
|
|
)
|
|
|
|
if(SLINT_FEATURE_COMPILER)
|
|
corrosion_set_hostbuild(slint-compiler)
|
|
endif()
|
|
|
|
add_library(Slint INTERFACE)
|
|
add_library(Slint::Slint ALIAS Slint)
|
|
target_link_libraries(Slint INTERFACE slint-cpp)
|
|
target_compile_features(Slint INTERFACE cxx_std_20)
|
|
if (MSVC)
|
|
target_compile_options(Slint INTERFACE /bigobj)
|
|
endif()
|
|
|
|
function(define_cargo_feature cargo-feature description default)
|
|
# turn foo-bar into SLINT_FEATURE_FOO_BAR
|
|
string(TOUPPER "${cargo-feature}" cmake_option)
|
|
string(REPLACE "-" "_" cmake_option "${cmake_option}")
|
|
set(cmake_option "SLINT_FEATURE_${cmake_option}")
|
|
option("${cmake_option}" "${description}" ${default})
|
|
|
|
if(${cmake_option})
|
|
list(APPEND features ${cargo-feature})
|
|
endif()
|
|
|
|
set(features "${features}" PARENT_SCOPE)
|
|
add_feature_info(${cmake_option} ${cmake_option} ${description})
|
|
endfunction()
|
|
|
|
function(define_cargo_dependent_feature cargo-feature description default depends_condition)
|
|
# turn foo-bar into SLINT_FEATURE_FOO_BAR
|
|
string(TOUPPER "${cargo-feature}" cmake_option)
|
|
string(REPLACE "-" "_" cmake_option "${cmake_option}")
|
|
set(cmake_option "SLINT_FEATURE_${cmake_option}")
|
|
cmake_dependent_option("${cmake_option}" "${description}" ${default} ${depends_condition} OFF)
|
|
|
|
if(${cmake_option})
|
|
list(APPEND features ${cargo-feature})
|
|
endif()
|
|
|
|
set(features "${features}" PARENT_SCOPE)
|
|
add_feature_info(${cmake_option} ${cmake_option} ${description})
|
|
endfunction()
|
|
|
|
# Features that are mapped to features in the Rust crate. These and their
|
|
# defaults need to be kept in sync with the Rust bit.
|
|
|
|
define_cargo_feature(freestanding "Enable use of freestanding environment. This is only for bare-metal systems. Most other features are incompatible with this one" OFF)
|
|
|
|
# Compat options (must be declared after the STD feature, but before the other renderer features)
|
|
function(define_renderer_winit_compat_option renderer)
|
|
string(TOUPPER "${renderer}" cmake_option)
|
|
string(REPLACE "-" "_" cmake_option "${cmake_option}")
|
|
cmake_dependent_option("SLINT_FEATURE_RENDERER_WINIT_${cmake_option}" "Compat option equivalent to SLINT_FEATURE_RENDERER_${cmake_option}" OFF "NOT SLINT_FEATURE_FREESTANDING" OFF)
|
|
if(SLINT_FEATURE_RENDERER_WINIT_${cmake_option})
|
|
set("SLINT_FEATURE_RENDERER_${cmake_option}" ON PARENT_SCOPE)
|
|
message("SLINT_FEATURE_RENDERER_WINIT_${cmake_option} is deprecated, use SLINT_FEATURE_RENDERER_${cmake_option} instead")
|
|
endif()
|
|
endfunction()
|
|
define_renderer_winit_compat_option(femtovg)
|
|
define_renderer_winit_compat_option(skia)
|
|
define_renderer_winit_compat_option(skia-opengl)
|
|
define_renderer_winit_compat_option(skia-vulkan)
|
|
define_renderer_winit_compat_option(software)
|
|
|
|
define_cargo_dependent_feature(interpreter "Enable support for the Slint interpeter to load .slint files at run-time" ON "NOT SLINT_FEATURE_FREESTANDING")
|
|
|
|
define_cargo_dependent_feature(backend-winit "Enable support for the winit crate to interaction with all windowing systems." ON "NOT SLINT_FEATURE_FREESTANDING")
|
|
define_cargo_dependent_feature(backend-winit-x11 "Enable support for the winit create to interact only with the X11 windowing system on Unix. Enable this option and turn off SLINT_FEATURE_BACKEND_WINIT for a smaller build with just X11 support on Unix." OFF "NOT SLINT_FEATURE_FREESTANDING")
|
|
define_cargo_dependent_feature(backend-winit-wayland "Enable support for the winit create to interact only with the wayland windowing system on Unix. Enable this option and turn off SLINT_FEATURE_BACKEND_WINIT for a smaller build with just wayland support." OFF "NOT SLINT_FEATURE_FREESTANDING")
|
|
|
|
define_cargo_dependent_feature(renderer-femtovg "Enable support for the OpenGL ES 2.0 based FemtoVG rendering engine." ON "NOT SLINT_FEATURE_FREESTANDING")
|
|
define_cargo_dependent_feature(renderer-skia "Enable support for the Skia based rendering engine." OFF "NOT SLINT_FEATURE_FREESTANDING")
|
|
define_cargo_dependent_feature(renderer-skia-opengl "Enable support for the Skia based rendering engine with its OpenGL backend." OFF "NOT SLINT_FEATURE_FREESTANDING")
|
|
define_cargo_dependent_feature(renderer-skia-vulkan "Enable support for the Skia based rendering engine with its Vulkan backend." OFF "NOT SLINT_FEATURE_FREESTANDING")
|
|
define_cargo_feature(renderer-software "Enable support for the software renderer" OFF)
|
|
|
|
define_cargo_dependent_feature(backend-qt "Enable Qt based rendering backend" ON "NOT SLINT_FEATURE_FREESTANDING")
|
|
|
|
define_cargo_dependent_feature(backend-linuxkms "Enable support for the backend that renders a single window fullscreen on Linux (Experimental)" OFF "NOT SLINT_FEATURE_FREESTANDING")
|
|
|
|
define_cargo_dependent_feature(gettext "Enable support of translations using gettext" OFF "NOT SLINT_FEATURE_FREESTANDING")
|
|
define_cargo_dependent_feature(accessibility "Enable integration with operating system provided accessibility APIs" ON "NOT SLINT_FEATURE_FREESTANDING")
|
|
|
|
if (SLINT_FEATURE_FREESTANDING)
|
|
|
|
if (ESP_PLATFORM)
|
|
list(APPEND features "esp-backtrace/${IDF_TARGET}")
|
|
endif()
|
|
else (SLINT_FEATURE_FREESTANDING)
|
|
list(APPEND features std)
|
|
endif()
|
|
|
|
set_property(
|
|
TARGET slint-cpp
|
|
PROPERTY CORROSION_FEATURES
|
|
${features}
|
|
)
|
|
set_property(
|
|
TARGET slint-cpp
|
|
PROPERTY CORROSION_NO_DEFAULT_FEATURES
|
|
ON
|
|
)
|
|
|
|
if(SLINT_FEATURE_BACKEND_QT)
|
|
# For the CMake build don't rely on qmake being in PATH but use CMake to locate Qt. This
|
|
# means usually CMAKE_PREFIX_PATH is set.
|
|
find_package(Qt6 6.2 QUIET COMPONENTS Core Widgets)
|
|
|
|
if(NOT TARGET Qt::qmake)
|
|
find_package(Qt5 5.15 QUIET COMPONENTS Core Widgets)
|
|
endif()
|
|
endif(SLINT_FEATURE_BACKEND_QT)
|
|
|
|
if(TARGET Qt::qmake)
|
|
set_property(
|
|
TARGET slint-cpp
|
|
APPEND
|
|
PROPERTY CORROSION_ENVIRONMENT_VARIABLES
|
|
QMAKE=$<TARGET_PROPERTY:Qt::qmake,LOCATION>
|
|
)
|
|
set(SLINT_STYLE_DEFAULT "native")
|
|
else()
|
|
set_property(
|
|
TARGET slint-cpp
|
|
APPEND
|
|
PROPERTY CORROSION_ENVIRONMENT_VARIABLES
|
|
SLINT_NO_QT=1
|
|
)
|
|
set(SLINT_STYLE_DEFAULT "fluent")
|
|
endif()
|
|
|
|
set(SLINT_STYLE "" CACHE STRING "The Slint Widget Style")
|
|
|
|
if(SLINT_STYLE)
|
|
set_property(GLOBAL PROPERTY SLINT_STYLE ${SLINT_STYLE})
|
|
else(SLINT_STYLE)
|
|
set_property(GLOBAL PROPERTY SLINT_STYLE ${SLINT_STYLE_DEFAULT})
|
|
endif(SLINT_STYLE)
|
|
|
|
if(SLINT_FEATURE_RENDERER_SKIA OR SLINT_FEATURE_RENDERER_SKIA_OPENGL OR SLINT_FEATURE_RENDERER_SKIA_VULKAN)
|
|
find_program(CLANGCC clang)
|
|
find_program(CLANGCXX clang++)
|
|
if(CLANGCC AND CLANGCXX)
|
|
set_property(
|
|
TARGET slint-cpp
|
|
APPEND
|
|
PROPERTY CORROSION_ENVIRONMENT_VARIABLES
|
|
CLANGCC=${CLANGCC}
|
|
)
|
|
set_property(
|
|
TARGET slint-cpp
|
|
APPEND
|
|
PROPERTY CORROSION_ENVIRONMENT_VARIABLES
|
|
CLANGCXX=${CLANGCXX}
|
|
)
|
|
endif()
|
|
|
|
# The Skia cross-build requires a host C compiler (due to some build dependencies of rust-skia),
|
|
# so cc.rs will first look for CC_<triplet> and then HOST_CC.
|
|
# When cross-compiling, CMake doesn't really know what the host compiler is. Corrosion will set
|
|
# HOST_CC to $CC, which is a good bet. Unfortunately in Yocto environments, CC will be set to
|
|
# the cross-compiler. The same applies to CFLAGS, which may contain target specific options.
|
|
# So the hack to solve this is two-fold:
|
|
# * We look for clang or gcc in PATH - unprefixed those are usually host compilers.
|
|
# * Through corrosion we know the correct host value of CC_<triplet>.
|
|
# Finally, we set CC_<host triplet> to clang or gcc and empty CFLAGS_<host triplet>
|
|
if(CMAKE_CROSSCOMPILING AND Rust_CARGO_HOST_TARGET)
|
|
if(CLANGCC)
|
|
set(host_cc "${CLANGCC}")
|
|
else()
|
|
find_program(GCC gcc)
|
|
if (GCC)
|
|
set(host_cc "${GCC}")
|
|
endif()
|
|
endif()
|
|
if(host_cc)
|
|
string(REPLACE "-" "_" cargo_host_target_underscore "${Rust_CARGO_HOST_TARGET}")
|
|
set_property(
|
|
TARGET slint-cpp
|
|
APPEND
|
|
PROPERTY CORROSION_ENVIRONMENT_VARIABLES
|
|
CC_${cargo_host_target_underscore}=${host_cc}
|
|
)
|
|
set_property(
|
|
TARGET slint-cpp
|
|
APPEND
|
|
PROPERTY CORROSION_ENVIRONMENT_VARIABLES
|
|
CFLAGS_${cargo_host_target_underscore}=
|
|
)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
file(GLOB api_headers RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/include/"
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/include/*.h")
|
|
|
|
foreach(header IN LISTS api_headers)
|
|
set_property(TARGET Slint APPEND PROPERTY PUBLIC_HEADER include/${header})
|
|
endforeach()
|
|
|
|
set(generated_headers
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_enums_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_enums.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_builtin_structs_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_builtin_structs.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_string_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_brush_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_sharedvector_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_properties_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_image_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_color_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_pathdata_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_qt_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_platform_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_generated_public.h
|
|
)
|
|
|
|
if(SLINT_FEATURE_INTERPRETER)
|
|
list(APPEND generated_headers
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_interpreter_internal.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/generated_include/slint_interpreter_generated_public.h
|
|
)
|
|
endif()
|
|
|
|
|
|
foreach(header IN LISTS generated_headers)
|
|
set_property(TARGET Slint APPEND PROPERTY PUBLIC_HEADER ${header})
|
|
endforeach()
|
|
|
|
target_include_directories(Slint INTERFACE
|
|
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/generated_include>
|
|
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
|
|
$<INSTALL_INTERFACE:include/slint>
|
|
)
|
|
|
|
if(SLINT_FEATURE_COMPILER)
|
|
add_executable(Slint::slint-compiler ALIAS slint-compiler)
|
|
include(${CMAKE_CURRENT_LIST_DIR}/cmake/SlintMacro.cmake)
|
|
endif()
|
|
|
|
export(TARGETS Slint slint-cpp
|
|
NAMESPACE Slint:: FILE "${CMAKE_BINARY_DIR}/lib/cmake/Slint/SlintTargets.cmake")
|
|
install(EXPORT SlintTargets NAMESPACE Slint:: DESTINATION lib/cmake/Slint)
|
|
install(TARGETS Slint slint-cpp
|
|
EXPORT SlintTargets LIBRARY DESTINATION lib PUBLIC_HEADER DESTINATION include/slint)
|
|
|
|
include(CMakePackageConfigHelpers)
|
|
include(GNUInstallDirs)
|
|
|
|
install(FILES $<TARGET_FILE:${slint_cpp_impl}> TYPE LIB)
|
|
|
|
if(WIN32)
|
|
install(FILES $<TARGET_LINKER_FILE:${slint_cpp_impl}> TYPE LIB)
|
|
endif()
|
|
|
|
if(SLINT_FEATURE_COMPILER)
|
|
install(PROGRAMS $<TARGET_FILE:slint-compiler> TYPE BIN)
|
|
endif()
|
|
|
|
# Corrosion sets the `IMPORTED` locations late to allow us to set OUTPUT_DIRECTORY
|
|
# target properties. This function must be deferred until after Corrosion set the
|
|
# locations. Since we are writing to a config file Generator expressions are not
|
|
# an option.
|
|
function(_slint_write_configure_file)
|
|
foreach(prop
|
|
IMPORTED_LOCATION IMPORTED_LOCATION_DEBUG IMPORTED_LOCATION_RELEASE
|
|
IMPORTED_LOCATION_RELWITHDEBINFO IMPORTED_LOCATION_MINSIZEREL
|
|
IMPORTED_IMPLIB IMPORTED_IMPLIB_DEBUG IMPORTED_IMPLIB_RELEASE
|
|
IMPORTED_IMPLIB_RELWITHDEBINFO IMPORTED_IMPLIB_MINSIZEREL)
|
|
get_target_property(value ${slint_cpp_impl} ${prop})
|
|
|
|
if(value)
|
|
get_filename_component(value ${value} NAME)
|
|
list(APPEND SLINT_LIB_PROPERTIES ${prop} "\${_IMPORT_PREFIX}/${CMAKE_INSTALL_LIBDIR}/${value}")
|
|
endif()
|
|
endforeach()
|
|
|
|
get_property(_SLINT_STYLE GLOBAL PROPERTY SLINT_STYLE)
|
|
configure_package_config_file("cmake/SlintConfig.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/lib/cmake/Slint/SlintConfig.cmake" INSTALL_DESTINATION lib/cmake/Slint)
|
|
endfunction()
|
|
|
|
cmake_language(DEFER CALL _slint_write_configure_file)
|
|
|
|
write_basic_package_version_file(
|
|
${CMAKE_CURRENT_BINARY_DIR}/lib/cmake/Slint/SlintConfigVersion.cmake
|
|
VERSION 1.2.2
|
|
COMPATIBILITY SameMinorVersion
|
|
)
|
|
|
|
install(FILES
|
|
"${CMAKE_CURRENT_BINARY_DIR}/lib/cmake/Slint/SlintConfig.cmake"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/lib/cmake/Slint/SlintConfigVersion.cmake"
|
|
DESTINATION lib/cmake/Slint
|
|
)
|
|
|
|
if(SLINT_FEATURE_COMPILER)
|
|
install(FILES
|
|
"${CMAKE_CURRENT_LIST_DIR}/cmake/SlintMacro.cmake"
|
|
DESTINATION lib/cmake/Slint
|
|
)
|
|
endif()
|
|
|
|
option(SLINT_PACKAGE_BUNDLE_QT "Internal setting to install Qt binary in the packages" OFF)
|
|
|
|
if(SLINT_PACKAGE_BUNDLE_QT)
|
|
if(WIN32)
|
|
find_package(Qt6 6.0 COMPONENTS Core Gui Widgets Svg)
|
|
install(
|
|
FILES
|
|
$<TARGET_FILE:Qt6::Core>
|
|
$<TARGET_FILE:Qt6::Gui>
|
|
$<TARGET_FILE:Qt6::Widgets>
|
|
$<TARGET_FILE:Qt6::Svg>
|
|
TYPE LIB)
|
|
|
|
install(
|
|
FILES ${Qt6_DIR}/../../../plugins/platforms/qwindows.dll
|
|
DESTINATION plugins/platforms)
|
|
install(
|
|
FILES ${Qt6_DIR}/../../../plugins/styles/qwindowsvistastyle.dll
|
|
DESTINATION plugins/styles)
|
|
install(
|
|
FILES ${Qt6_DIR}/../../../plugins/imageformats/qsvg.dll
|
|
DESTINATION plugins/imageformats)
|
|
|
|
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../licenses/ DESTINATION LICENSES)
|
|
|
|
set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
|
|
include(InstallRequiredSystemLibraries)
|
|
install(FILES ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS} TYPE LIB)
|
|
endif()
|
|
endif(SLINT_PACKAGE_BUNDLE_QT)
|
|
|
|
set(CPACK_PACKAGE_NAME "Slint-cpp")
|
|
set(CPACK_PACKAGE_VENDOR "Slint")
|
|
set(CPACK_VERBATIM_VARIABLES true)
|
|
set(CPACK_PACKAGE_VERSION_MAJOR 1)
|
|
set(CPACK_PACKAGE_VERSION_MINOR 2)
|
|
set(CPACK_PACKAGE_VERSION_PATCH 2)
|
|
set(CPACK_PACKAGE_HOMEPAGE_URL "https://slint.dev")
|
|
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_LIST_DIR}/../../LICENSE.md")
|
|
set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_LIST_DIR}/README.md")
|
|
set(CPACK_STRIP_FILES ON)
|
|
set(CPACK_NSIS_DEFINES "ManifestDPIAware true")
|
|
|
|
if(NOT WIN32)
|
|
set(CPACK_GENERATOR "TGZ")
|
|
set(CPACK_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
|
|
endif(NOT WIN32)
|
|
|
|
include(CPack)
|
|
|
|
if(SLINT_BUILD_TESTING)
|
|
add_subdirectory(tests)
|
|
endif()
|