diff options
Diffstat (limited to 'cmake/QtBuildInternals/QtBuildInternalsConfig.cmake')
-rw-r--r-- | cmake/QtBuildInternals/QtBuildInternalsConfig.cmake | 232 |
1 files changed, 232 insertions, 0 deletions
diff --git a/cmake/QtBuildInternals/QtBuildInternalsConfig.cmake b/cmake/QtBuildInternals/QtBuildInternalsConfig.cmake new file mode 100644 index 0000000000..a81ef3cb8b --- /dev/null +++ b/cmake/QtBuildInternals/QtBuildInternalsConfig.cmake @@ -0,0 +1,232 @@ +if (CMAKE_VERSION VERSION_LESS 3.1.0) + message(FATAL_ERROR "Qt requires at least CMake version 3.1.0") +endif() + +###################################### +# +# Macros for building Qt modules +# +###################################### + +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsExtra.cmake") + include(${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsExtra.cmake) +endif() + +macro(qt_set_up_build_internals_paths) + # Set up the paths for the cmake modules located in the prefix dir. Prepend, so the paths are + # least important compared to the source dir ones, but more important than command line + # provided ones. + set(QT_CMAKE_MODULE_PATH "${QT_BUILD_INTERNALS_PATH}/../${QT_CMAKE_EXPORT_NAMESPACE}") + list(PREPEND CMAKE_MODULE_PATH "${QT_CMAKE_MODULE_PATH}") + + # When doing a non-prefix build, prepend the qtbase source cmake directory to CMAKE_MODULE_PATH, + # so that if a change is done in cmake/QtBuild.cmake, it gets automatically picked up when + # building qtdeclarative, rather than having to build qtbase first (which will copy + # QtBuild.cmake to the build dir). This is similar to qmake non-prefix builds, where the + # source qtbase/mkspecs directory is used. + if(NOT QT_WILL_INSTALL) + list(PREPEND CMAKE_MODULE_PATH "${QT_SOURCE_TREE}/cmake") + endif() + + # If the repo has its own cmake modules, include those in the module path. + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + endif() + + # Find the cmake files when doing a standalone tests build. + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../cmake") + list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../cmake") + endif() +endmacro() + +# Set up the build internal paths unless explicitly requested not to. +if(NOT QT_BUILD_INTERNALS_SKIP_CMAKE_MODULE_PATH_ADDITION) + qt_set_up_build_internals_paths() +endif() + +# Define some constants to check for certain platforms, etc. +# Needs to be loaded before qt_repo_build() to handle require() clauses before even starting a repo +# build. +include(QtPlatformSupport) + +macro(qt_build_repo_begin) + # Qt specific setup common for all modules: + include(QtSetup) + include(FeatureSummary) + + # Optionally include a repo specific Setup module. + include(${PROJECT_NAME}Setup OPTIONAL) + include(QtRepoSetup OPTIONAL) + + # Find Apple frameworks if needed. + qt_find_apple_system_frameworks() + + # Decide whether tools will be built. + qt_check_if_tools_will_be_built() +endmacro() + +macro(qt_build_repo_end) + if(NOT QT_BUILD_STANDALONE_TESTS) + # Delayed actions on some of the Qt targets: + include(QtPostProcess) + + # Install the repo-specific cmake find modules. + qt_path_join(__qt_repo_install_dir ${QT_CONFIG_INSTALL_DIR} ${INSTALL_CMAKE_NAMESPACE}) + + if(NOT PROJECT_NAME STREQUAL "QtBase") + if (EXISTS cmake) + qt_copy_or_install(DIRECTORY cmake/ + DESTINATION "${__qt_repo_install_dir}" + FILES_MATCHING PATTERN "Find*.cmake" + ) + endif() + endif() + + # Print a feature summary: + feature_summary(WHAT PACKAGES_FOUND + REQUIRED_PACKAGES_NOT_FOUND + RECOMMENDED_PACKAGES_NOT_FOUND + OPTIONAL_PACKAGES_NOT_FOUND + RUNTIME_PACKAGES_NOT_FOUND + FATAL_ON_MISSING_REQUIRED_PACKAGES) + endif() + + qt_print_build_instructions() +endmacro() + +function(qt_print_build_instructions) + if(NOT PROJECT_NAME STREQUAL "QtBase" OR QT_BUILD_STANDALONE_TESTS) + return() + endif() + + set(build_command "cmake --build . --parallel") + set(install_command "cmake --install .") + + message("Qt is now configured for building. Just run '${build_command}'.") + if(QT_WILL_INSTALL) + message("Once everything is built, you must run '${install_command}'.") + message("Qt will be installed into '${CMAKE_INSTALL_PREFIX}'") + else() + message("Once everything is built, Qt is installed.") + message("You should NOT run '${install_command}'") + message("Note that this build cannot be deployed to other machines or devices.") + endif() + message("To configure and build other modules, you can use the following convenience script: + ${CMAKE_INSTALL_PREFIX}/${INSTALL_BINDIR}/qt-cmake") + message("\nIf reconfiguration fails for some reason, try to remove 'CMakeCache.txt' \ +from the build directory \n") +endfunction() + +macro(qt_build_repo) + qt_build_repo_begin(${ARGN}) + + # If testing is enabled, try to find the qtbase Test package. + # Do this before adding src, because there might be test related conditions + # in source. + if (BUILD_TESTING AND NOT QT_BUILD_STANDALONE_TESTS) + find_package(Qt6 ${PROJECT_VERSION} CONFIG REQUIRED COMPONENTS Test) + endif() + + if(NOT QT_BUILD_STANDALONE_TESTS) + if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/CMakeLists.txt") + add_subdirectory(src) + endif() + + if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tools/CMakeLists.txt") + add_subdirectory(tools) + endif() + endif() + + if (BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt") + add_subdirectory(tests) + if(QT_NO_MAKE_TESTS) + set_property(DIRECTORY tests PROPERTY EXCLUDE_FROM_ALL TRUE) + endif() + endif() + + qt_build_repo_end() + + if (BUILD_EXAMPLES AND BUILD_SHARED_LIBS + AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/examples/CMakeLists.txt" + AND NOT QT_BUILD_STANDALONE_TESTS) + add_subdirectory(examples) + if(QT_NO_MAKE_EXAMPLES) + set_property(DIRECTORY examples PROPERTY EXCLUDE_FROM_ALL TRUE) + endif() + endif() +endmacro() + +macro(qt_set_up_standalone_tests_build) + # Remove this macro once all usages of it have been removed. + # Standalone tests are not handled via the main repo project and qt_build_tests. +endmacro() + +macro(qt_build_tests) + if(QT_BUILD_STANDALONE_TESTS) + # Find location of TestsConfig.cmake. These contain the modules that need to be + # find_package'd when testing. + set(_qt_build_tests_install_prefix + "${QT_CONFIG_INSTALL_DIR}/${INSTALL_CMAKE_NAMESPACE}BuildInternals/StandaloneTests") + if(QT_WILL_INSTALL) + qt_path_join(_qt_build_tests_install_prefix + ${CMAKE_INSTALL_PREFIX} ${_qt_build_tests_install_prefix}) + endif() + include("${_qt_build_tests_install_prefix}/${CMAKE_PROJECT_NAME}TestsConfig.cmake" OPTIONAL) + + # Of course we always need the test module as well. + find_package(Qt6 ${PROJECT_VERSION} CONFIG REQUIRED COMPONENTS Test) + endif() + + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/auto/CMakeLists.txt") + add_subdirectory(auto) + endif() + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/benchmarks/CMakeLists.txt" AND QT_BUILD_BENCHMARKS) + add_subdirectory(benchmarks) + endif() + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/manual/CMakeLists.txt") + add_subdirectory(manual) + endif() +endmacro() + +macro(qt_examples_build_begin) + # Examples that are built as part of the Qt build need to use the CMake config files from the + # build dir, because they are not installed yet in a prefix build. + # Appending to CMAKE_PREFIX_PATH helps find the initial Qt6Config.cmake. + # Appending to QT_EXAMPLES_CMAKE_PREFIX_PATH helps find components of Qt6, because those + # find_package calls use NO_DEFAULT_PATH, and thus CMAKE_PREFIX_PATH is ignored. + list(APPEND CMAKE_PREFIX_PATH "${CMAKE_BINARY_DIR}") + list(APPEND QT_EXAMPLES_CMAKE_PREFIX_PATH "${CMAKE_BINARY_DIR}") + # Also make sure the CMake config files do not recreate the already-existing targets + set(QT_NO_CREATE_TARGETS TRUE) + set(BACKUP_CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ${CMAKE_FIND_ROOT_PATH_MODE_PACKAGE}) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE "BOTH") +endmacro() + +macro(qt_examples_build_end) + # We use AUTOMOC/UIC/RCC in the examples. Make sure to not fail on a fresh Qt build, that e.g. the moc binary does not exist yet. + + # This function gets all targets below this directory + function(get_all_targets _result _dir) + get_property(_subdirs DIRECTORY "${_dir}" PROPERTY SUBDIRECTORIES) + foreach(_subdir IN LISTS _subdirs) + get_all_targets(${_result} "${_subdir}") + endforeach() + get_property(_sub_targets DIRECTORY "${_dir}" PROPERTY BUILDSYSTEM_TARGETS) + set(${_result} ${${_result}} ${_sub_targets} PARENT_SCOPE) + endfunction() + + get_all_targets(targets "${CMAKE_CURRENT_SOURCE_DIR}") + + foreach(target ${targets}) + qt_autogen_tools(${target} ENABLE_AUTOGEN_TOOLS "moc" "rcc") + if(TARGET Qt::Widgets) + qt_autogen_tools(${target} ENABLE_AUTOGEN_TOOLS "uic") + endif() + endforeach() + + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ${BACKUP_CMAKE_FIND_ROOT_PATH_MODE_PACKAGE}) +endmacro() + +if (ANDROID) + include(${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsAndroid.cmake) +endif() |