diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index d7e400e..0000000 --- a/CMakeLists.txt +++ /dev/null @@ -1,771 +0,0 @@ -# === This file is part of Calamares - === -# -# SPDX-FileCopyrightText: 2017 Adriaan de Groot -# SPDX-License-Identifier: BSD-2-Clause -# -### -# -# Calamares is Free Software: see the License-Identifier above. -# -# Individual files may have different licenses (like the CMake -# infrastructure, which is BSD-2-Clause licensed). Check the SPDX -# identifiers in each file. -# -### -# -# Generally, this CMakeLists.txt will find all the dependencies for Calamares -# and complain appropriately. See below (later in this file) for CMake-level -# options. There are some "secret" options as well: -# -# SKIP_MODULES : a space or semicolon-separated list of directory names -# under src/modules that should not be built. -# USE_ : fills in SKIP_MODULES for modules called -. -# WITH_ : try to enable (these usually default to ON). For -# a list of WITH_ grep CMakeCache.txt after running -# CMake once. These affect the ABI offered by Calamares. -# - PYBIND11 (use bundled pybind11, default ON, needs WITH_PYTHON) -# - PYTHON (enable Python Job modules, default ON if Python is found) -# - QML (enable QML UI View modules, default ON) -# - QT6 (use Qt6 rather than Qt5, default to OFF) -# The WITH_* options affect the ABI of Calamares: you must -# build (C++) modules for Calamares with the same WITH_* -# settings, or they may not load at all. -# BUILD_ : choose additional things to build -# - APPDATA (use AppData in packagechooser, requires QtXml) -# - APPSTREAM (use AppStream in packagechooser, requires libappstream-qt) -# - BUILD_CRASH_REPORTING (uses KCrash, rather than Calamares internal, for crash reporting) -# - SCHEMA_TESTING (requires Python, see ci/configvalidator.py) -# - TESTING (standard CMake option) -# DEBUG_ : special developer flags for debugging. -# PYTHONLIBS_VERSION : if set on the command-line, use a specific Python version -# -# Example usage: -# -# cmake . -DSKIP_MODULES="partition luksbootkeycfg" -# -# To obtain the version number of calamares, run CMake in script mode, e.g. -# cmake -P CMakeLists.txt - -cmake_minimum_required(VERSION 3.16 FATAL_ERROR) - -set(CALAMARES_VERSION 3.3.12) -set(CALAMARES_RELEASE_MODE ON) # Set to ON during a release - -if(CMAKE_SCRIPT_MODE_FILE) - include(${CMAKE_CURRENT_LIST_DIR}/CMakeModules/ExtendedVersion.cmake) - set(CMAKE_SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}) - extend_version( ${CALAMARES_VERSION} ${CALAMARES_RELEASE_MODE} _vshort _vlong ) - message("${_vlong}") - return() -endif() - -# Massage the version for CMake if there is a version-suffix -string(REGEX REPLACE "-.*" "" CALAMARES_VERSION_SHORT "${CALAMARES_VERSION}") -# And preserve the original version (suffix and all) because project() overwrites -# .. but if we're doing non-release builds, this gets replaced with git versioning. -set(CALAMARES_VERSION_LONG "${CALAMARES_VERSION}") - -project(CALAMARES VERSION ${CALAMARES_VERSION_SHORT} LANGUAGES C CXX HOMEPAGE_URL "https://calamares.io/") - -if(NOT CALAMARES_RELEASE_MODE AND CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR) - message(FATAL_ERROR "Do not build development versions in the source-directory.") -endif() -# Calamares in the 3.3 series promises ABI compatbility, so it sets a -# .so-version equal to the series number. We use ci/abicheck.sh to -# keep track of this. Note that the **alpha** releases also have -# such an .so-version, but are not ABI-stable yet. -set(CALAMARES_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}") - -### OPTIONS -# -option(INSTALL_POLKIT "Install Polkit configuration" ON) -option(INSTALL_COMPLETION "Install shell completions" OFF) -option(INSTALL_CONFIG "Install configuration files" OFF) -# When adding WITH_* that affects the ABI offered by libcalamares, -# also update libcalamares/CalamaresConfig.h.in -option(WITH_PYBIND11 "Use bundled pybind11 instead of Boost::Python" ON) -option(WITH_PYTHON "Enable Python modules API." ON) -option(WITH_QML "Enable QML UI options." ON) -option(WITH_QT6 "Use Qt6 instead of Qt5" OFF) -# -# Additional parts to build that do not affect ABI -option(BUILD_SCHEMA_TESTING "Enable schema-validation-tests" ON) -# Options for the calamares executable -option(BUILD_CRASH_REPORTING "Enable crash reporting with KCrash." ON) - -# Possible debugging flags are: -# - DEBUG_TIMEZONES draws latitude and longitude lines on the timezone -# widget and enables chatty debug logging, for dealing with the timezone -# location database. -# - DEBUG_FILESYSTEMS does extra logging and checking when looking at -# partition configuration. Lists known KPMCore FS types. -# - DEBUG_PARTITION_UNSAFE (see partition/CMakeLists.txt) -# - DEBUG_PARTITION_BAIL_OUT (see partition/CMakeLists.txt) - -# Special handling for Python versions: -# - If you set PYTHONLIBS_VERSION on the command-line, then -# that **exact** version will be searched for, and no other. -# - If you do not set PYTHONLIBS_VERSION on the command-line, -# any suitable version will be found -- but this can fail if -# you have multiple Python versions installed, only some of -# which include the development headers. - -### USE_* -# -# By convention, when there are multiple modules that implement similar -# functionality, and it only makes sense to have **at most one** of them -# enabled at any time, those modules are named -. -# For example, services-systemd and services-openrc. -# -# Setting up SKIP_MODULES to ignore "the ones you don't want" can be -# annoying and error-prone (e.g. if a new module shows up). The USE_* -# modules provide a way to do automatic selection. To pick exactly -# one of the implementations from group , set USE_ to the -# name of the implementation. If USE_ is unset, or empty, then -# all the implementations are enabled (this just means they are -# **available** to `settings.conf`, not that they are used). -# -# To explicitly disable a set of modules, set USE_=none -# (e.g. the literal string none), which won't match any of the -# modules but is handled specially. -# -# The following USE_* functionalities are available: -# - *services* picks one of the two service-configuration modules, -# for either systemd or openrc. This defaults to empty so that -# **both** modules are available. -set(USE_services "" CACHE STRING "Select the services module to use") - -### Calamares application info -# -set(CALAMARES_ORGANIZATION_NAME "Calamares") -set(CALAMARES_ORGANIZATION_DOMAIN "github.com/calamares") -set(CALAMARES_APPLICATION_NAME "Calamares") -set(CALAMARES_DESCRIPTION_SUMMARY "The distribution-independent installer framework") - -### Transifex (languages) info -# -# complete = 100% translated, -# good = nearly complete (use own judgement, right now >= 75%) -# ok = incomplete (more than 25% untranslated, at least 5% translated), -# incomplete = <5% translated, placeholder in tx; these are not included. -# -# Language en (source language) is added later. It isn't listed in -# Transifex either. Get the list of languages and their status -# from https://app.transifex.com/calamares/calamares/ , or (preferably) -# use ci/txstats.py to automatically check. -# -# When adding a new language, take care that it is properly loaded -# by the translation framework. Languages with alternate scripts -# (sr@latin in particular) or location (ca@valencia) need special -# handling in libcalamares/locale/Translation.h . -# -# NOTE: move ie (Interlingue) to _ok once Qt supports it. -# NOTE: update these lines by running `txstats.py`, or for full automation -# `txstats.py -e`. See also -# -# Total 80 languages -set( _tx_complete de en es_AR fi_FI hr hu ja lt tr_TR uk zh_TW ) -set( _tx_good az az_AZ be bg ca cs_CZ es fr fur he hi is it_IT ko - pl pt_BR pt_PT ru si sq sv zh_CN ) -set( _tx_ok ar as ast bn ca@valencia da el en_GB eo es_MX et eu fa - gl id ka ml mr nb nl oc ro sk sl sr sr@latin tg th vi ) -set( _tx_incomplete bqi es_PR gu ie ja-Hira kk kn lo lv mk ne_NP - ro_RO ta_IN te ur uz zh zh_HK ) -# Total 80 languages - -### Required versions -# -# See DEPENDENCIES section below. - -# The default build is with Qt5, but that is increasingly not the -# version installed-by-default on Linux systems. Upgrade the default -# if Qt5 isn't available but Qt6 is. This also saves messing around -# with special CMake flags for every script (e.g. ci/RELEASE.sh and -# ci/abicheck.sh). -if(NOT WITH_QT6) - find_package(Qt5Core QUIET) - if(NOT TARGET Qt5::Core) - find_package(Qt6Core QUIET) - if(TARGET Qt6::Core) - message(STATUS "Default Qt version (Qt5) not found, upgrading build to Qt6") - set(WITH_QT6 ON) - endif() - endif() -endif() -if(WITH_QT6) - message(STATUS "Building Calamares with Qt6") - set(qtname "Qt6") - set(kfname "KF6") - set(QT_VERSION 6.5.0) - set(ECM_VERSION 5.240) - set(KF_VERSION 5.240) # KDE Neon weirdness - # API that was deprecated before Qt 5.15 causes a compile error - add_compile_definitions(QT_DISABLE_DEPRECATED_BEFORE=0x060400) - # Something to add to filenames for this specific Qt version - set(QT_VERSION_SUFFIX "-qt6") -else() - message(STATUS "Building Calamares with Qt5") - set(qtname "Qt5") - set(kfname "KF5") - set(QT_VERSION 5.15.0) - set(ECM_VERSION 5.78) - set(KF_VERSION 5.78) - # API that was deprecated before Qt 5.15 causes a compile error - add_compile_definitions(QT_DISABLE_DEPRECATED_BEFORE=0x050f00) - # Something to add to filenames for this specific Qt version - set(QT_VERSION_SUFFIX "") -endif() - -set(BOOSTPYTHON_VERSION 1.72.0) -if(DEFINED PYTHONLIBS_VERSION) - set(PYTHONLIBS_EXTRA "EXACT") -else() - set(PYTHONLIBS_VERSION 3.6) - set(PYTHONLIBS_EXTRA "") -endif() -set(YAMLCPP_VERSION 0.5.1) - -### CMAKE SETUP -# -set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/CMakeModules") - -# Enable IN_LIST -cmake_policy(SET CMP0057 NEW) -# Let ``AUTOMOC`` and ``AUTOUIC`` process ``GENERATED`` files. -cmake_policy(SET CMP0071 NEW) -# Recognize more macros to trigger automoc -list(APPEND CMAKE_AUTOMOC_MACRO_NAMES - "K_PLUGIN_FACTORY_WITH_JSON" - "K_EXPORT_PLASMA_DATAENGINE_WITH_JSON" - "K_EXPORT_PLASMA_RUNNER" -) - -# CMake Modules -include(CMakePackageConfigHelpers) -include(CTest) -include(FeatureSummary) - -# Calamares Modules -include(CMakeColors) - -### C++ SETUP -# -set(CMAKE_CXX_STANDARD 20) -set(CMAKE_CXX_STANDARD_REQUIRED ON) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror=return-type") -set(CMAKE_CXX_FLAGS_DEBUG "-Og -g ${CMAKE_CXX_FLAGS_DEBUG}") -set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG") -set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG") -set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g") - -set(CMAKE_C_STANDARD 99) -set(CMAKE_C_STANDARD_REQUIRED ON) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall") -set(CMAKE_C_FLAGS_DEBUG "-Og -g") -set(CMAKE_C_FLAGS_MINSIZEREL "-Os -DNDEBUG") -set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG") -set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g") - -set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined -Wl,--fatal-warnings ${CMAKE_SHARED_LINKER_FLAGS}") - -# If no build type is set, pick a reasonable one -if(NOT CMAKE_BUILD_TYPE) - if(CALAMARES_RELEASE_MODE) - set(CMAKE_BUILD_TYPE "RelWithDebInfo") - else() - set(CMAKE_BUILD_TYPE "Debug") - endif() -endif() - -if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") - message(STATUS "Found Clang ${CMAKE_CXX_COMPILER_VERSION}, setting up Clang-specific compiler flags.") - - # Clang warnings: doing *everything* is counter-productive, since it warns - # about things which we can't fix (e.g. C++98 incompatibilities, but - # Calamares is C++17). - foreach( - CLANG_WARNINGS - -Weverything - -Wno-c++98-compat - -Wno-c++98-compat-pedantic - -Wno-padded - -Wno-undefined-reinterpret-cast - -Wno-global-constructors - -Wno-exit-time-destructors - -Wno-missing-prototypes - -Wno-documentation-unknown-command - -Wno-unknown-warning-option - ) - string(APPEND CMAKE_CXX_FLAGS " ${CLANG_WARNINGS}") - endforeach() - - # The dwarf-debugging flags are slightly different, too - string(APPEND CMAKE_CXX_FLAGS_DEBUG " -gdwarf") - string(APPEND CMAKE_C_FLAGS_DEBUG " -gdwarf") - - # Third-party code where we don't care so much about compiler warnings - # (because it's uncomfortable to patch) get different flags; use - # mark_thirdparty_code( [...] ) - # to switch off warnings for those sources. - set(SUPPRESS_3RDPARTY_WARNINGS "-Wno-everything") - - set(CMAKE_TOOLCHAIN_PREFIX "llvm-") - - # The path prefix is only relevant for CMake 3.16 and later, fixes #1286 - set(CMAKE_AUTOMOC_PATH_PREFIX OFF) - set(CALAMARES_AUTOMOC_OPTIONS "-butils/moc-warnings.h") - set(CALAMARES_AUTOUIC_OPTIONS --include utils/moc-warnings.h) -else() - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Woverloaded-virtual") - - set(SUPPRESS_3RDPARTY_WARNINGS "") -endif() - -# Use mark_thirdparty_code() to reduce warnings from the compiler -# on code that we're not going to fix. Call this with a list of files. -macro(mark_thirdparty_code) - set_source_files_properties( - ${ARGV} - PROPERTIES COMPILE_FLAGS "${SUPPRESS_3RDPARTY_WARNINGS}" COMPILE_DEFINITIONS "THIRDPARTY" - ) -endmacro() - -if(CMAKE_COMPILER_IS_GNUCXX) - if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 4.9) - message(STATUS "Found GNU g++ ${CMAKE_CXX_COMPILER_VERSION}, enabling colorized error messages.") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=auto") - endif() -endif() - -### DEPENDENCIES -# -find_package(${qtname} ${QT_VERSION} CONFIG REQUIRED Concurrent Core DBus Gui LinguistTools Network Svg Widgets) -if(WITH_QML) - find_package(${qtname} ${QT_VERSION} CONFIG REQUIRED Quick QuickWidgets) -endif() -# Note that some modules need more Qt modules, optionally. - -find_package(YAMLCPP ${YAMLCPP_VERSION}) -set_package_properties( - YAMLCPP - PROPERTIES - TYPE REQUIRED - DESCRIPTION "YAML parser for C++" - PURPOSE "Parsing of configuration files" -) - -find_package(Polkit${qtname}-1) -if(INSTALL_POLKIT) - set_package_properties( - Polkit${qtname}-1 - PROPERTIES - TYPE REQUIRED - ) -endif() -set_package_properties( - Polkit${qtname}-1 - PROPERTIES - DESCRIPTION "${qtname} support for Polkit" - URL "https://cgit.kde.org/polkit-qt-1.git" - PURPOSE "Polkit${qtname}-1 helps with installing Polkit configuration" -) - -# Find ECM once, and add it to the module search path; Calamares -# modules that need ECM can do -# if(ECM_FOUND) -# no need to mess with the module path after. -find_package(ECM ${ECM_VERSION} NO_MODULE) -if(ECM_FOUND) - message(STATUS "Found KDE ECM ${ECM_MODULE_PATH}") - set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${CMAKE_MODULE_PATH}) - if(BUILD_TESTING) - # ECM implies that we can build the tests, too - find_package(${qtname} COMPONENTS Test REQUIRED) - include(ECMAddTests) - endif() - include(KDEInstallDirs) -endif() - -find_package(${kfname}CoreAddons ${KF_VERSION} QUIET) -set_package_properties( - ${kfname}CoreAddons - PROPERTIES - TYPE REQUIRED - DESCRIPTION "KDE Framework CoreAddons" - URL "https://api.kde.org/frameworks/" - PURPOSE "Essential Framework for AboutData and Macros" -) - -# After this point, there should be no REQUIRED find_packages, -# since we want tidy reporting of optional dependencies. -feature_summary( - WHAT REQUIRED_PACKAGES_NOT_FOUND - FATAL_ON_MISSING_REQUIRED_PACKAGES - DESCRIPTION "The following REQUIRED packages were not found:" - QUIET_ON_EMPTY -) - -# -# OPTIONAL DEPENDENCIES -# -# First, set KF back to optional so that any missing components don't trip us up. -find_package(${kfname}Crash ${KF_VERSION} QUIET) -set_package_properties( - ${kfname}Crash - PROPERTIES - TYPE OPTIONAL - DESCRIPTION "KDE Framework Crash" - URL "https://api.kde.org/frameworks/" - PURPOSE "Framework for sending Crash Dumps" -) - -if(NOT TARGET ${kfname}::Crash) - if(BUILD_CRASH_REPORTING) - message(WARNING "BUILD_CRASH_REPORTING is set, but ${kfname}::Crash is not available.") - endif() - set(BUILD_CRASH_REPORTING OFF) -endif() - -find_package(Python ${PYTHONLIBS_VERSION} ${PYTHONLIBS_EXTRA} COMPONENTS Interpreter Development) -set_package_properties( - Python - PROPERTIES - DESCRIPTION "Python3 interpreter." - URL "https://python.org" - PURPOSE "Python3 interpreter for certain tests." -) - -set(_schema_explanation "") -if(Python_Interpreter_FOUND) - if(BUILD_SCHEMA_TESTING) - # The configuration validator script has some dependencies, - # and if they are not installed, don't run. If errors out - # with exit(1) on missing dependencies. - if(CALAMARES_CONFIGVALIDATOR_CHECKED) - message(STATUS "Using cached config-validation result") - set(_validator_deps ${CALAMARES_CONFIGVALIDATOR_RESULT}) - else() - execute_process( - COMMAND ${Python_EXECUTABLE} "${CMAKE_SOURCE_DIR}/ci/configvalidator.py" -x - RESULT_VARIABLE _validator_deps - ) - set(CALAMARES_CONFIGVALIDATOR_CHECKED TRUE CACHE INTERNAL "Dependencies for configvalidator checked") - set(CALAMARES_CONFIGVALIDATOR_RESULT ${_validator_deps} - CACHE INTERNAL "Result of configvalidator dependency check" - ) - endif() - # It should never succeed, but only returns 1 when the imports fail - if(_validator_deps EQUAL 1) - message(STATUS "Checked for config-validation dependencies: NOT-FOUND") - set(_schema_explanation " Missing dependencies for configvalidator.py.") - set(BUILD_SCHEMA_TESTING OFF) - else() - message(STATUS "Checked for config-validation dependencies: found") - endif() - else() - set(CALAMARES_CONFIGVALIDATOR_CHECKED OFF CACHE INTERNAL "Dependencies for configvalidator checked") - endif() -else() - # Can't run schema tests without Python3. - set(_schema_explanation " Missing Python3.") - set(BUILD_SCHEMA_TESTING OFF) - set(CALAMARES_CONFIGVALIDATOR_CHECKED OFF CACHE INTERNAL "Dependencies for configvalidator checked") -endif() -add_feature_info(yaml-schema BUILD_SCHEMA_TESTING "Validate YAML (config files) with schema.${_schema_explanation}") - -if(NOT Python_Development_FOUND) - message(STATUS "Disabling Python modules") - set(WITH_PYTHON OFF) - set(WITH_PYBIND11 OFF) - set(WITH_BOOST_PYTHON OFF) -endif() - -if(WITH_PYTHON AND NOT WITH_PYBIND11) - set(WITH_BOOST_PYTHON ON) - find_package(boost_python) - if(NOT TARGET Boost::python) - find_package(Boost ${BOOSTPYTHON_VERSION} COMPONENTS python) - set_package_properties(Boost PROPERTIES - PURPOSE "Boost.Python is used for Python job modules (because WITH_PYBIND11 is OFF)." - TYPE REQUIRED - ) - else() - message(STATUS "Found boost_python with target Boost::python") - set(Boost_FOUND ON) - endif() -endif() -add_feature_info(python WITH_PYTHON "Enable Python-modules") -add_feature_info(python-pybind11 WITH_PYBIND11 "Python-modules through pybind11") -add_feature_info(python-boost WITH_BOOST_PYTHON "Python-modules through Boost::Python") - -# Now we know the state of the ABI-options, copy them into "Calamares_" -# prefixed variables, to match how the variables would-be-named -# when building out-of-tree. -set(Calamares_WITH_PYTHON ${WITH_PYTHON}) -set(Calamares_WITH_PYBIND11 ${WITH_PYBIND11}) -set(Calamares_WITH_BOOST_PYTHON ${WITH_BOOST_PYTHON}) -set(Calamares_WITH_QML ${WITH_QML}) -set(Calamares_WITH_QT6 ${WITH_QT6}) - -### Transifex Translation status -# -# Construct language lists for use. This massages the language lists if -# needed and checks for some obvious errors. The actual work of -# compiling translations is done in the lang/ directory. -# - -set(curr_tx ${_tx_complete} ${_tx_good} ${_tx_ok} ${_tx_incomplete}) -set(tx_errors OFF) -if(curr_tx) - # New in list - foreach(l ${curr_tx}) - set(p_l "lang/calamares_${l}.ts") - if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${p_l}) - message(WARNING "Language ${l} has no .ts file yet.") - set(tx_errors ON) - endif() - endforeach() - - unset(p_l) - unset(l) -endif() -unset(curr_tx) -if(tx_errors) - message(FATAL_ERROR "Translation warnings, see above.") -endif() - -set(CALAMARES_TRANSLATION_LANGUAGES en ${_tx_complete} ${_tx_good} ${_tx_ok}) -if(NOT CALAMARES_RELEASE_MODE) - # Outside of release mode, enable all the languages - list(APPEND CALAMARES_TRANSLATION_LANGUAGES ${_tx_incomplete}) -endif() -list(SORT CALAMARES_TRANSLATION_LANGUAGES) -list(REMOVE_DUPLICATES CALAMARES_TRANSLATION_LANGUAGES) - -add_subdirectory(lang) # i18n tools - -### Example Distro -# -# For testing purposes Calamares includes a very, very, limited sample -# distro called "Generic". The root filesystem of "Generic" lives in -# data/example-root and can be squashed up as part of the build, so -# that a pure-upstream run of ./calamares -d from the build directory -# (with all the default settings and configurations) can actually -# do an complete example run. -# -# Some binaries from the build host (e.g. /bin and /lib) are also -# squashed into the example filesystem. -# -# To build the example distro (for use by the default, example, -# unsquashfs module), build the target 'example-distro', eg.: -# -# make example-distro -# -find_program(mksquashfs_PROGRAM mksquashfs) -if(mksquashfs_PROGRAM) - set(mksquashfs_FOUND ON) - set(src_fs ${CMAKE_SOURCE_DIR}/data/example-root/) - set(dst_fs ${CMAKE_BINARY_DIR}/example.sqfs) - if(EXISTS ${src_fs}) - # based on the build host. If /lib64 exists, assume it is needed. - # Collect directories needed for a minimal binary distro, - # Note that the last path component is added to the root, so - # if you add /usr/sbin here, it will be put into /sbin_1. - # Add such paths to /etc/profile under ${src_fs}. - set(candidate_fs /sbin /bin /lib /lib64) - set(host_fs "") - foreach(c_fs ${candidate_fs}) - if(EXISTS ${c_fs}) - list(APPEND host_fs ${c_fs}) - endif() - endforeach() - add_custom_command( - OUTPUT ${dst_fs} - COMMAND ${mksquashfs_PROGRAM} ${src_fs} ${dst_fs} -all-root - COMMAND ${mksquashfs_PROGRAM} ${host_fs} ${dst_fs} -all-root - ) - add_custom_target(example-distro DEPENDS ${dst_fs}) - endif() -else() - set(mksquashfs_FOUND OFF) -endif() -# Doesn't list mksquashfs as an optional dep, though, because it -# hasn't been sent through the find_package() scheme. -# -# "http://tldp.org/HOWTO/SquashFS-HOWTO/creatingandusing.html" -add_feature_info(ExampleDistro ${mksquashfs_FOUND} "Create example-distro target.") - -### CALAMARES PROPER -# - -# Additional info for non-release builds. The "extended" version information -# with date and git information (commit, dirty status) is used only -# by CalamaresVersionX.h, which is included by consumers that need a full -# version number with all that information; normal consumers can include -# CalamaresVersion.h with more stable numbers. -if(NOT CALAMARES_RELEASE_MODE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git/") - include(ExtendedVersion) - extend_version( "${CALAMARES_VERSION}" OFF CALAMARES_VERSION_SHORT CALAMARES_VERSION_LONG ) -endif() - -# Special define for RC (e.g. not-a-release) builds. -# This is consumed via the CalamaresConfig.h header. -if(NOT CALAMARES_RELEASE_MODE) - set(CALAMARES_VERSION_RC 1) -endif() - -# enforce using constBegin, constEnd for const-iterators -add_definitions(-DQT_STRICT_ITERATORS -DQT_SHARED -DQT_SHAREDPOINTER_TRACK_POINTERS) - -# set paths -set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}") -set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}") -set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}") - -# Better default installation paths: GNUInstallDirs defines -# CMAKE_INSTALL_FULL_SYSCONFDIR to be CMAKE_INSTALL_PREFIX/etc by default -# but we really want /etc -if(NOT DEFINED CMAKE_INSTALL_SYSCONFDIR) - set(CMAKE_INSTALL_SYSCONFDIR "/etc") -endif() - -# make predefined install dirs available everywhere -include(GNUInstallDirs) - -# This is used by CalamaresAddLibrary; once Calamares is installed, -# the CalamaresConfig.cmake module sets this variable to the IMPORTED -# libraries for Calamares. -set(Calamares_LIBRARIES calamares) - -add_subdirectory(3rdparty/kdsingleapplication) -if(WITH_PYBIND11) - add_subdirectory(3rdparty/pybind11) -endif() -add_subdirectory(src) - -add_feature_info(Python ${WITH_PYTHON} "Python job modules") -add_feature_info(Pybind11 ${WITH_PYBIND11} "Python using bundled pybind11") -add_feature_info(Qml ${WITH_QML} "QML UI support") -add_feature_info(Polkit ${INSTALL_POLKIT} "Install Polkit files") -add_feature_info(KCrash ${BUILD_CRASH_REPORTING} "Crash dumps via KCrash") - -### Post-source configuration -# -# -find_package(${kfname} ${KF_VERSION} QUIET COMPONENTS CoreAddons) - -### CMake infrastructure installation -# -# -set(CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/Calamares" CACHE PATH "Installation directory for CMake files") -set(CMAKE_INSTALL_FULL_CMAKEDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_CMAKEDIR}") - -export(PACKAGE Calamares) -configure_package_config_file( - "CalamaresConfig.cmake.in" - "${PROJECT_BINARY_DIR}/CalamaresConfig.cmake" - INSTALL_DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" - PATH_VARS CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR CMAKE_INSTALL_DATADIR -) -write_basic_package_version_file( - ${PROJECT_BINARY_DIR}/CalamaresConfigVersion.cmake - VERSION ${PROJECT_VERSION} - COMPATIBILITY SameMajorVersion -) -install(EXPORT Calamares DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" FILE "CalamaresTargets.cmake" NAMESPACE Calamares::) - -# Install the cmake files -install( - FILES - "${PROJECT_BINARY_DIR}/CalamaresConfig.cmake" - "${PROJECT_BINARY_DIR}/CalamaresConfigVersion.cmake" - "CMakeModules/CalamaresAddBrandingSubdirectory.cmake" - "CMakeModules/CalamaresAddLibrary.cmake" - "CMakeModules/CalamaresAddModuleSubdirectory.cmake" - "CMakeModules/CalamaresAddPlugin.cmake" - "CMakeModules/CalamaresAddTest.cmake" - "CMakeModules/CalamaresAddTranslations.cmake" - "CMakeModules/CalamaresAutomoc.cmake" - "CMakeModules/CalamaresCheckModuleSelection.cmake" - "CMakeModules/CMakeColors.cmake" - "CMakeModules/FindYAMLCPP.cmake" - DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" -) - -### Miscellaneous installs -# -# -if(INSTALL_POLKIT) - install(FILES com.github.calamares.calamares.policy DESTINATION "${POLKITQT-1_POLICY_FILES_INSTALL_DIR}") -endif() - -if(INSTALL_COMPLETION) - if(NOT CMAKE_INSTALL_BASHCOMPLETIONDIR) - set(CMAKE_INSTALL_BASHCOMPLETIONDIR "${CMAKE_INSTALL_DATADIR}/bash-completion/completions") - endif() - - install(FILES ${CMAKE_SOURCE_DIR}/data/completion/bash/calamares DESTINATION "${CMAKE_INSTALL_BASHCOMPLETIONDIR}") -endif() - -install(FILES calamares.desktop DESTINATION ${CMAKE_INSTALL_DATADIR}/applications) - -install(FILES man/calamares.8 DESTINATION ${CMAKE_INSTALL_MANDIR}/man8/) - -if(INSTALL_CONFIG) - install(FILES settings.conf DESTINATION share/calamares) -endif() - -### Uninstall -# -# -configure_file( - "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" - "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" - IMMEDIATE - @ONLY -) - -add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) - -### Developer convenience -# -# The module support files -- .desc files, .conf files -- are copied into the build -# directory so that it is possible to run `calamares -d` from there. Copy the -# top-level settings.conf as well, into the build directory. -if(settings.conf IS_NEWER_THAN ${CMAKE_BINARY_DIR}/settings.conf) - configure_file(settings.conf ${CMAKE_BINARY_DIR}/settings.conf COPYONLY) -endif() - - - -### CMAKE SUMMARY REPORT -# -get_directory_property(SKIPPED_MODULES DIRECTORY src/modules DEFINITION LIST_SKIPPED_MODULES) -calamares_explain_skipped_modules( ${SKIPPED_MODULES} ) - -feature_summary(WHAT ENABLED_FEATURES DESCRIPTION "The following features are enabled" QUIET_ON_EMPTY) -feature_summary(WHAT DISABLED_FEATURES DESCRIPTION "The following features have been disabled:" QUIET_ON_EMPTY) -feature_summary( - WHAT OPTIONAL_PACKAGES_NOT_FOUND - DESCRIPTION "The following OPTIONAL packages were not found:" - QUIET_ON_EMPTY -) -feature_summary( - WHAT REQUIRED_PACKAGES_NOT_FOUND - FATAL_ON_MISSING_REQUIRED_PACKAGES - DESCRIPTION "The following REQUIRED packages were not found:" - QUIET_ON_EMPTY -) - -### PACKAGING -# -# Note: most distro's will do distro-specific packaging rather than -# using CPack, and this duplicates information in the AppStream, too. -set(CPACK_PACKAGE_VENDOR calamares) -set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "A Linux system installer") -set(CPACK_PACKAGE_DESCRIPTION - "Calamares is a Linux system installer, intended for Linux distributions to use on their ISOs and other bootable media to install the distribution to the end-user's computer. Calamares can also be used as an OEM configuration tool. It is modular, extensible and highly-configurable for Linux distributions from all five major Linux families." -) -set(CPACK_PACKAGE_ICON "data/images/squid.png") - -include(CPack)